SolveResult

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/eccaai-com/json-schema/eccaai-com-solve-result-schema.json",
  "title": "SolveResult",
  "x-generated": "2026-11-06",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/_original/eccaai-com-api-openapi.json#/components/schemas/SolveResult",
  "type": "object",
  "required": [
    "answer",
    "synthesis",
    "verification",
    "meta"
  ],
  "properties": {
    "answer": {
      "type": "string"
    },
    "synthesis": {
      "$ref": "#/$defs/Synthesis"
    },
    "verification": {
      "type": "object",
      "description": "Rule-based argument verification of the question text.",
      "properties": {
        "findings": {
          "type": "array",
          "items": {
            "type": "object"
          }
        }
      },
      "additionalProperties": true
    },
    "meta": {
      "type": "object",
      "properties": {
        "proofSeal": {
          "type": [
            "object",
            "null"
          ],
          "description": "The server's seal over this answer, also the done event's proofSeal: {v, engines, issuedAt, sig}, HMAC-SHA256 over the stored question, the engines that answered ok, the stored answer and every other stored field. Post it back to /api/proof-link with the answer (body.proofSeal or meta.proofSeal) and the proof is stored sealed, so its page may say Checked by N AIs on ECCA. Any other share is stored unsealed and its page says Shared answer. Not checked by ECCA. null when sealing is not configured."
        },
        "latencyMs": {
          "type": "integer"
        },
        "providers": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Engine"
          }
        },
        "enginesConfigured": {
          "type": "integer"
        },
        "enginesLive": {
          "type": "integer",
          "description": "Measured per answer: engines that actually returned."
        },
        "convergenceScore": {
          "type": [
            "number",
            "null"
          ]
        },
        "convergenceMethod": {
          "type": "string"
        },
        "disagreements": {
          "type": "array"
        },
        "divergenceScore": {
          "type": [
            "number",
            "null"
          ]
        },
        "mode": {
          "type": "string"
        },
        "cascade": {
          "type": [
            "object",
            "null"
          ],
          "description": "Free deep solves only: gated / escalated outcome and engine counts."
        },
        "cache": {
          "type": "object",
          "description": "Present only on a labeled semantic-cache hit.",
          "properties": {
            "hit": {
              "const": true
            },
            "similarity": {
              "type": "number"
            },
            "ageMs": {
              "type": "integer"
            }
          }
        },
        "downgraded": {
          "type": "boolean"
        },
        "reason": {
          "type": "string",
          "enum": [
            "free-daily-deep-limit"
          ]
        },
        "deepLimit": {
          "type": "integer"
        },
        "upsell": {
          "type": "string"
        },
        "upgradeUrl": {
          "type": "string"
        },
        "streamTruncated": {
          "type": "boolean"
        }
      },
      "additionalProperties": true
    },
    "mode": {
      "type": "string",
      "description": "Echoed adjudication mode, when one was used."
    },
    "modeReport": {
      "type": [
        "object",
        "null"
      ],
      "description": "Deterministic report for verify / tournament / premortem / audit / check. For check it is the CheckResult plus proof and, when no proof was minted, proofRefusal."
    },
    "check": {
      "$ref": "#/$defs/CheckResult"
    },
    "proof": {
      "type": [
        "object",
        "null"
      ],
      "description": "Mode check only. The proof minted through POST /api/proof-link with the caller's own credentials, or null when that route did not mint one.",
      "properties": {
        "id": {
          "type": "string"
        },
        "path": {
          "type": "string"
        },
        "url": {
          "type": "string"
        },
        "createdAt": {
          "type": "string",
          "format": "date-time"
        }
      }
    },
    "proofRefusal": {
      "type": "object",
      "description": "Mode check only, present when proof is null: the body POST /api/proof-link answered plus its HTTP status. For a caller without a session it is error sign-in-required (status 401); a free account past its daily share cap gets proof-share-limit (status 429)."
    }
  },
  "$defs": {
    "CheckResult": {
      "type": "object",
      "description": "Mode check: the dispatched panel's canonical final answer against the candidate's. Deterministic; agreement is never inferred from wording. agrees or dissents needs a checkable candidate answer and at least two engines with a checkable answer; otherwise the verdict is unmeasurable and summary says no agreement is claimed.",
      "required": [
        "verdict",
        "measurable",
        "candidateCanonical",
        "panelCanonical",
        "agreeingEngineIds",
        "dissentingEngineIds",
        "candidateShownToEngines"
      ],
      "properties": {
        "verdict": {
          "type": "string",
          "enum": [
            "agrees",
            "dissents",
            "unmeasurable"
          ]
        },
        "measurable": {
          "type": "boolean"
        },
        "reason": {
          "type": [
            "string",
            "null"
          ],
          "enum": [
            null,
            "candidate-unextractable",
            "panel-unextractable",
            "panel-too-small",
            "panel-split"
          ],
          "description": "Why the verdict is unmeasurable; null when measurable."
        },
        "candidateCanonical": {
          "type": [
            "string",
            "null"
          ]
        },
        "panelCanonical": {
          "type": [
            "string",
            "null"
          ],
          "description": "The majority canonical final answer of the engines that gave one; null when none did or the panel split evenly."
        },
        "agreeingEngineIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Engines whose canonical final answer equals the candidate's."
        },
        "dissentingEngineIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Engines whose canonical final answer differs from the candidate's."
        },
        "unmeasuredEngineIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "Engines that answered without a checkable final answer."
        },
        "candidateShownToEngines": {
          "const": false
        },
        "contradiction": {
          "type": [
            "object",
            "null"
          ],
          "description": "Set only when verdict is dissents. candidateSpan {start, end, text} is the candidate's final answer as written, located by the canonical-answer extractor's own match (end exclusive, UTF-16 offsets into the submitted candidate); correctClaim {canonical, engineIds, engineId, text} is the panel's answer as the selected engine wrote it, with every engine that reached it; citation {title, url} is the first https source the dispatch carried, else null; basis is canonical-extractor-match."
        },
        "summary": {
          "type": "string"
        }
      }
    },
    "Engine": {
      "type": "object",
      "description": "One registered engine role. Identity only (id/name/role) on the registry read; live telemetry (status/ok/ms) after a dispatch. The registry holds up to 6 roles; how many answered is measured per response in meta.enginesLive.",
      "properties": {
        "id": {
          "type": "string",
          "enum": [
            "speed",
            "depth",
            "breadth",
            "logic",
            "context",
            "agentic"
          ]
        },
        "name": {
          "type": "string"
        },
        "role": {
          "type": "string"
        },
        "status": {
          "type": "string",
          "enum": [
            "live",
            "gated",
            "unavailable",
            "unconfigured"
          ]
        },
        "ok": {
          "type": "boolean"
        },
        "ms": {
          "type": [
            "integer",
            "null"
          ]
        },
        "receipt": {
          "type": "string"
        }
      }
    },
    "Synthesis": {
      "type": "object",
      "properties": {
        "ratified_conclusion": {
          "type": "string"
        },
        "adversarial_refutations": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "alternative": {
                "type": "string"
              },
              "reason": {
                "type": "string"
              },
              "confidenceBounds": {},
              "ruleId": {
                "type": "string"
              }
            }
          }
        },
        "consensus_score": {
          "type": [
            "number",
            "null"
          ],
          "description": "Pairwise lexical convergence across engines that answered; null when fewer than two answered."
        },
        "convergence_method": {
          "type": "string",
          "enum": [
            "pairwise-lexical-jaccard",
            "insufficient-independent-responses"
          ]
        },
        "disagreements": {
          "type": "array",
          "items": {
            "type": "object"
          }
        },
        "divergence_score": {
          "type": [
            "number",
            "null"
          ]
        },
        "providers": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Engine"
          }
        },
        "enginesLive": {
          "type": "integer"
        },
        "total_latency_ms": {
          "type": "integer"
        },
        "trace_id": {
          "type": "string"
        }
      },
      "additionalProperties": true
    }
  }
}