@gmickel/gno 1.19.0 → 1.20.0

package/spec/output-schemas/ask.schema.json

@@ -4,7 +4,96 @@
   "title": "GNO Ask Response",
   "description": "Response from gno ask command",
   "type": "object",
+  "additionalProperties": false,
   "required": ["query", "mode", "results", "meta"],
+  "allOf": [
+    {
+      "if": {
+        "properties": { "verification": {} },
+        "required": ["verification"]
+      },
+      "then": {
+        "required": ["answer", "citations"],
+        "properties": {
+          "answer": {},
+          "citations": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": { "evidenceId": {} },
+              "required": ["evidenceId"]
+            }
+          },
+          "meta": {
+            "type": "object",
+            "required": ["verificationRequested", "abstained"],
+            "properties": {
+              "verificationRequested": { "const": true },
+              "abstained": {}
+            }
+          }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "meta": {
+            "type": "object",
+            "required": ["verificationRequested"],
+            "properties": { "verificationRequested": { "const": true } }
+          }
+        },
+        "required": ["meta"]
+      },
+      "then": {
+        "properties": { "verification": {} },
+        "required": ["verification"]
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "verification": {
+            "type": "object",
+            "properties": {
+              "claims": {
+                "type": "object",
+                "properties": { "answerStatus": { "const": "abstained" } },
+                "required": ["answerStatus"]
+              }
+            },
+            "required": ["claims"]
+          }
+        },
+        "required": ["verification"]
+      },
+      "then": {
+        "properties": {
+          "citations": { "type": "array", "maxItems": 0 },
+          "meta": {
+            "type": "object",
+            "properties": { "abstained": { "const": true } }
+          }
+        }
+      },
+      "else": {
+        "if": {
+          "properties": { "verification": {} },
+          "required": ["verification"]
+        },
+        "then": {
+          "properties": {
+            "citations": { "type": "array", "minItems": 1 },
+            "meta": {
+              "type": "object",
+              "properties": { "abstained": { "const": false } }
+            }
+          }
+        }
+      }
+    }
+  ],
   "$defs": {
     "searchResult": {
       "type": "object",
@@ -165,8 +254,13 @@
       "description": "Citations for the answer",
       "items": {
         "type": "object",
+        "additionalProperties": false,
         "required": ["docid", "uri"],
         "properties": {
+          "evidenceId": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+          },
           "docid": {
             "type": "string",
             "description": "Document ID",
@@ -197,8 +291,106 @@
         "$ref": "#/$defs/searchResult"
       }
     },
+    "verification": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schemaVersion",
+        "mode",
+        "capsule",
+        "freshness",
+        "claims",
+        "semantic"
+      ],
+      "properties": {
+        "schemaVersion": { "const": "1.0" },
+        "mode": { "const": "closed_capsule" },
+        "capsule": {
+          "$ref": "gno://schemas/context-capsule-v1@1.0"
+        },
+        "freshness": {
+          "$ref": "gno://schemas/context-capsule-verification@1.0"
+        },
+        "claims": {
+          "$ref": "gno://schemas/claim-verification@1.0"
+        },
+        "semantic": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "status",
+            "reason",
+            "schemaRequested",
+            "schemaEnforced",
+            "modelFingerprint",
+            "configFingerprint",
+            "verifierFingerprint",
+            "candidateClaims",
+            "verifiedClaims",
+            "unresolvedClaims",
+            "modelCalls",
+            "durationMs"
+          ],
+          "properties": {
+            "status": {
+              "enum": ["completed", "unavailable", "failed"]
+            },
+            "reason": {
+              "enum": [
+                "verified",
+                "no_candidates",
+                "verifier_unavailable",
+                "structured_output_unavailable",
+                "input_limit_exceeded",
+                "generation_failed",
+                "invalid_output"
+              ]
+            },
+            "schemaRequested": { "type": "boolean" },
+            "schemaEnforced": { "type": "boolean" },
+            "modelFingerprint": {
+              "oneOf": [
+                {
+                  "type": "string",
+                  "pattern": "^[a-f0-9]{64}$"
+                },
+                { "type": "null" }
+              ]
+            },
+            "configFingerprint": {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            },
+            "verifierFingerprint": {
+              "oneOf": [
+                {
+                  "type": "string",
+                  "pattern": "^[a-f0-9]{64}$"
+                },
+                { "type": "null" }
+              ]
+            },
+            "candidateClaims": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "verifiedClaims": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "unresolvedClaims": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "modelCalls": { "enum": [0, 1] },
+            "durationMs": { "type": "number", "minimum": 0 }
+          }
+        }
+      }
+    },
     "meta": {
       "type": "object",
+      "additionalProperties": false,
       "description": "Retrieval metadata",
       "required": ["expanded", "reranked", "vectorsUsed"],
       "properties": {
@@ -250,6 +442,12 @@
           "type": "boolean",
           "description": "Whether an answer was generated"
         },
+        "verificationRequested": {
+          "type": "boolean"
+        },
+        "abstained": {
+          "type": "boolean"
+        },
         "totalResults": {
           "type": "integer",
           "description": "Number of results returned",

package/spec/output-schemas/claim-verification.schema.json

@@ -0,0 +1,291 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "gno://schemas/claim-verification@1.0",
+  "title": "GNO Claim Verification Result",
+  "description": "Deterministic claim spans, Capsule-bound evidence, semantic verdicts, coverage, and abstention.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "coordinateSpace",
+    "capsuleId",
+    "answerHash",
+    "coverageThreshold",
+    "claims",
+    "rejectedCitations",
+    "coverage",
+    "answerStatus",
+    "abstained",
+    "abstentionReason",
+    "abstentionText"
+  ],
+  "properties": {
+    "schemaVersion": { "const": "1.0" },
+    "coordinateSpace": { "const": "utf16_code_units" },
+    "capsuleId": { "$ref": "#/definitions/sha256" },
+    "answerHash": { "$ref": "#/definitions/sha256" },
+    "coverageThreshold": { "const": 1 },
+    "claims": {
+      "type": "array",
+      "maxItems": 256,
+      "items": { "$ref": "#/definitions/claim" }
+    },
+    "rejectedCitations": {
+      "type": "array",
+      "maxItems": 256,
+      "items": { "$ref": "#/definitions/rejectedCitation" }
+    },
+    "coverage": { "$ref": "#/definitions/coverage" },
+    "answerStatus": { "enum": ["verified", "abstained"] },
+    "abstained": { "type": "boolean" },
+    "abstentionReason": {
+      "enum": [
+        "contradiction_detected",
+        "coverage_below_threshold",
+        "no_substantive_claims",
+        "citation_hygiene_failed",
+        null
+      ]
+    },
+    "abstentionText": { "type": ["string", "null"] }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "abstained": { "const": false } } },
+      "then": {
+        "properties": {
+          "answerStatus": { "const": "verified" },
+          "abstentionReason": { "type": "null" },
+          "abstentionText": { "type": "null" },
+          "rejectedCitations": { "type": "array", "maxItems": 0 },
+          "claims": {
+            "type": "array",
+            "not": {
+              "contains": {
+                "type": "object",
+                "required": ["rejectedCitations"],
+                "properties": {
+                  "rejectedCitations": {
+                    "type": "array",
+                    "minItems": 1
+                  }
+                }
+              }
+            }
+          },
+          "coverage": {
+            "type": "object",
+            "properties": {
+              "totalClaims": { "type": "integer", "minimum": 1 },
+              "supportedRatio": { "const": 1 },
+              "contradictedClaims": { "const": 0 },
+              "insufficientClaims": { "const": 0 },
+              "uncertainClaims": { "const": 0 }
+            }
+          }
+        }
+      }
+    },
+    {
+      "if": { "properties": { "abstained": { "const": true } } },
+      "then": {
+        "properties": {
+          "answerStatus": { "const": "abstained" },
+          "abstentionReason": { "type": "string" },
+          "abstentionText": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  ],
+  "definitions": {
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "evidenceReference": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "evidenceId",
+        "uri",
+        "startLine",
+        "endLine",
+        "text",
+        "sourceHash",
+        "mirrorHash",
+        "passageHash"
+      ],
+      "properties": {
+        "evidenceId": { "$ref": "#/definitions/sha256" },
+        "uri": {
+          "type": "string",
+          "maxLength": 2048,
+          "pattern": "^gno://"
+        },
+        "startLine": { "type": "integer", "minimum": 1 },
+        "endLine": { "type": "integer", "minimum": 1 },
+        "text": { "type": "string", "minLength": 1 },
+        "sourceHash": { "$ref": "#/definitions/sha256" },
+        "mirrorHash": { "$ref": "#/definitions/sha256" },
+        "passageHash": { "$ref": "#/definitions/sha256" }
+      }
+    },
+    "rejectedCitation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["marker", "start", "end", "evidenceId", "reason"],
+      "properties": {
+        "marker": { "type": "string", "minLength": 1 },
+        "start": { "type": "integer", "minimum": 0 },
+        "end": { "type": "integer", "minimum": 1 },
+        "evidenceId": {
+          "oneOf": [{ "$ref": "#/definitions/sha256" }, { "type": "null" }]
+        },
+        "reason": {
+          "enum": [
+            "malformed_citation",
+            "out_of_capsule",
+            "freshness_unavailable",
+            "freshness_receipt_invalid",
+            "freshness_receipt_mismatch",
+            "evidence_stale",
+            "evidence_missing",
+            "orphan_citation"
+          ]
+        }
+      }
+    },
+    "claim": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "claimId",
+        "text",
+        "start",
+        "end",
+        "status",
+        "confidence",
+        "rationaleCode",
+        "verifierFingerprint",
+        "evidence",
+        "rejectedCitations"
+      ],
+      "properties": {
+        "claimId": { "$ref": "#/definitions/sha256" },
+        "text": { "type": "string", "minLength": 1 },
+        "start": { "type": "integer", "minimum": 0 },
+        "end": { "type": "integer", "minimum": 1 },
+        "status": {
+          "enum": ["supported", "contradicted", "insufficient", "uncertain"]
+        },
+        "confidence": {
+          "oneOf": [
+            { "type": "number", "minimum": 0, "maximum": 1 },
+            { "type": "null" }
+          ]
+        },
+        "rationaleCode": {
+          "enum": [
+            "semantic_entailment",
+            "semantic_contradiction",
+            "no_valid_evidence",
+            "semantic_judgment_unavailable"
+          ]
+        },
+        "verifierFingerprint": {
+          "oneOf": [{ "$ref": "#/definitions/sha256" }, { "type": "null" }]
+        },
+        "evidence": {
+          "type": "array",
+          "maxItems": 256,
+          "items": { "$ref": "#/definitions/evidenceReference" }
+        },
+        "rejectedCitations": {
+          "type": "array",
+          "maxItems": 256,
+          "items": { "$ref": "#/definitions/rejectedCitation" }
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "status": { "enum": ["supported", "contradicted"] }
+            }
+          },
+          "then": {
+            "properties": {
+              "confidence": { "type": "number" },
+              "verifierFingerprint": { "$ref": "#/definitions/sha256" },
+              "evidence": { "type": "array", "minItems": 1 }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "supported" } } },
+          "then": {
+            "properties": {
+              "rationaleCode": { "const": "semantic_entailment" }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "contradicted" } } },
+          "then": {
+            "properties": {
+              "rationaleCode": { "const": "semantic_contradiction" }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "status": { "enum": ["insufficient", "uncertain"] }
+            }
+          },
+          "then": {
+            "properties": {
+              "confidence": { "type": "null" },
+              "verifierFingerprint": { "type": "null" }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "insufficient" } } },
+          "then": {
+            "properties": {
+              "rationaleCode": { "const": "no_valid_evidence" },
+              "evidence": { "type": "array", "maxItems": 0 }
+            }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "uncertain" } } },
+          "then": {
+            "properties": {
+              "rationaleCode": { "const": "semantic_judgment_unavailable" },
+              "evidence": { "type": "array", "minItems": 1 }
+            }
+          }
+        }
+      ]
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "totalClaims",
+        "supportedClaims",
+        "contradictedClaims",
+        "insufficientClaims",
+        "uncertainClaims",
+        "supportedRatio"
+      ],
+      "properties": {
+        "totalClaims": { "type": "integer", "minimum": 0 },
+        "supportedClaims": { "type": "integer", "minimum": 0 },
+        "contradictedClaims": { "type": "integer", "minimum": 0 },
+        "insufficientClaims": { "type": "integer", "minimum": 0 },
+        "uncertainClaims": { "type": "integer", "minimum": 0 },
+        "supportedRatio": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  }
+}

package/spec/output-schemas/context-capsule-v1.schema.json

@@ -196,6 +196,23 @@
                 { "type": "null" }
               ]
             },
+            "intent": {
+              "oneOf": [
+                { "type": "string", "minLength": 1, "maxLength": 16384 },
+                { "type": "null" }
+              ]
+            },
+            "exclude": {
+              "type": "array",
+              "maxItems": 128,
+              "items": { "type": "string", "minLength": 1, "maxLength": 256 }
+            },
+            "minScore": {
+              "oneOf": [
+                { "type": "number", "minimum": 0, "maximum": 1 },
+                { "type": "null" }
+              ]
+            },
             "queryModes": {
               "type": "array",
               "maxItems": 128,
@@ -203,7 +220,8 @@
             },
             "limit": { "type": "integer", "minimum": 1 },
             "candidateLimit": { "type": "integer", "minimum": 1 },
-            "graphRequested": { "type": "boolean" }
+            "graphRequested": { "type": "boolean" },
+            "rerankRequested": { "type": "boolean" }
           }
         },
         "capabilityStates": {
@@ -538,6 +556,23 @@
         },
         "retrievalRank": { "type": "integer", "minimum": 1 },
         "selectionRank": { "type": "integer", "minimum": 1 },
+        "retrievalSources": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 6,
+          "uniqueItems": true,
+          "items": {
+            "enum": [
+              "bm25",
+              "vector",
+              "bm25_variant",
+              "vector_variant",
+              "hyde",
+              "graph"
+            ]
+          }
+        },
+        "graphExpanded": { "type": "boolean" },
         "facets": { "$ref": "#/definitions/facets" },
         "trust": { "const": "untrusted" },
         "egress": {

package/src/app/context-runtime-contract.ts

@@ -24,8 +24,9 @@ import { resolveModelUri } from "../llm/registry";
 const fingerprint = (value: unknown): string =>
   sha256Text(canonicalVerifierJson(value));
 
-const configFingerprint = (deps: ContextCapsuleRuntimeDeps): string =>
-  fingerprint(deps.config);
+export const contextRuntimeConfigFingerprint = (
+  deps: Pick<ContextCapsuleRuntimeDeps, "config">
+): string => fingerprint(deps.config);
 
 const configuredContextFingerprint = (
   deps: ContextCapsuleRuntimeDeps
@@ -75,7 +76,7 @@ const capsuleCapabilityStates = (
     ["embedding_unavailable"]
   ),
   reranking: capabilityState(
-    input.depthPolicy !== "fast",
+    input.depthPolicy !== "fast" && !input.noRerank,
     draft.retrieval.reranked,
     ["reranking_unavailable"]
   ),
@@ -191,10 +192,14 @@ export const projectContextCapsule = (
       request: {
         author: input.author,
         lang: input.lang,
+        intent: input.intent,
+        exclude: input.exclude,
+        minScore: input.minScore,
         queryModes: input.queryModes,
         limit: input.limit,
         candidateLimit: input.candidateLimit,
         graphRequested: input.graph,
+        rerankRequested: input.depthPolicy !== "fast" && !input.noRerank,
       },
       capabilityStates,
       indexSnapshot: {
@@ -221,7 +226,7 @@ export const projectContextCapsule = (
         : null,
     },
     fingerprints: {
-      config: configFingerprint(deps),
+      config: contextRuntimeConfigFingerprint(deps),
       retrieval: retrievalFingerprint(base, snapshots.contextFingerprint),
       embeddingModel: capabilities.semanticSearch
         ? sha256Text(deps.embedPort?.modelUri ?? "")
@@ -292,7 +297,7 @@ export const currentContextFingerprints = (
   capsule: ContextCapsuleV1,
   deps: ContextCapsuleRuntimeDeps
 ) => ({
-  config: configFingerprint(deps),
+  config: contextRuntimeConfigFingerprint(deps),
   retrieval: retrievalFingerprint(capsule, configuredContextFingerprint(deps)),
   embeddingModel: capsule.capabilities.semanticSearch
     ? sha256Text(

package/src/app/context-runtime-input.ts

@@ -315,16 +315,40 @@ export const normalizeContextBuildInput = (
       "Context graph flag must be boolean"
     );
   }
+  if (input.noRerank !== undefined && typeof input.noRerank !== "boolean") {
+    throw new ContextRuntimeError(
+      "invalid_filter",
+      "Context noRerank flag must be boolean"
+    );
+  }
+  if (
+    input.minScore !== undefined &&
+    (typeof input.minScore !== "number" ||
+      !Number.isFinite(input.minScore) ||
+      input.minScore < 0 ||
+      input.minScore > 1)
+  ) {
+    throw new ContextRuntimeError(
+      "invalid_filter",
+      "Context minimum score must be between 0 and 1"
+    );
+  }
   const author =
     typeof input.author === "string"
       ? input.author.normalize("NFC").trim()
       : null;
   const lang =
     typeof input.lang === "string" ? input.lang.normalize("NFC").trim() : null;
+  const intent =
+    typeof input.intent === "string"
+      ? input.intent.normalize("NFC").trim()
+      : null;
   if (
     (input.author !== undefined &&
       (!author || author.length > MAX_FILTER_LENGTH)) ||
-    (input.lang !== undefined && (!lang || !isValidLanguageHint(lang)))
+    (input.lang !== undefined && (!lang || !isValidLanguageHint(lang))) ||
+    (input.intent !== undefined &&
+      (!intent || intent.length > MAX_TEXT_LENGTH || intent.includes("\r")))
   ) {
     throw new ContextRuntimeError(
       "invalid_filter",
@@ -344,9 +368,13 @@ export const normalizeContextBuildInput = (
     categories: canonicalFilters(input.categories, "categories"),
     author,
     lang,
+    intent,
+    exclude: canonicalFilters(input.exclude, "exclude"),
+    minScore: input.minScore ?? null,
     since: temporalRange.since,
     until: temporalRange.until,
     graph: input.graph ?? false,
+    noRerank: input.noRerank ?? false,
     limit,
     candidateLimit,
     budgetTokens,