kibi-cli 2.32.0 → 2.36.0

package/src/public/proof-protocol-types.d.ts

@@ -94,14 +94,66 @@ export type ProofContract = Readonly<{
     | "exhaustive"
     | "typecheck"
     | "arithmetic"
-    | "smt";
+    | "smt"
+    | "rule"
+    | "state_machine"
+    | "regex"
+    | "source";
   domain_source?: Readonly<{ symbol_id: string; export?: string }>;
   witness?: Readonly<{ path: string }>;
   constraint_source?: Readonly<{ fact_ids: readonly string[] }>;
-  value_source?: readonly Readonly<{ symbol_id: string; export?: string }>[];
+  value_source?: readonly (
+    | Readonly<{
+        symbol_id: string;
+        export?: string;
+        /** value (default): the export is a number; count: the size of a list, set, map or object. */
+        measure?: "value" | "count";
+      }>
+    | Readonly<{
+        /** A project source whose members Kibi counts. */
+        source: ProofSourceSpec;
+        measure: "count";
+      }>
+  )[];
   proves?: readonly string[];
+  predicate_source?: Readonly<
+    Record<
+      string,
+      Readonly<{
+        symbol_id: string;
+        export?: string;
+        /** The predicate is a test harness driving these code symbols. */
+        harness_for?: readonly string[];
+      }>
+    >
+  >;
+  domains?: Readonly<
+    Record<
+      string,
+      | Readonly<{ symbol_id: string; export?: string }>
+      | Readonly<{ source: ProofSourceSpec }>
+    >
+  >;
+  initial_source?: Readonly<{ symbol_id: string; export?: string }>;
+  pattern_source?: Readonly<{ symbol_id: string; export?: string }>;
+  /** kind source: the project source Kibi reads. */
+  source?: ProofSourceSpec;
 }>;
 
+/** A project source a source proof, a rule domain or a count reads; see proof-sources. */
+export type ProofSourceSpec = Readonly<Record<string, unknown>> &
+  Readonly<{
+    reader:
+      | "json"
+      | "yaml"
+      | "glob"
+      | "openapi"
+      | "references"
+      | "schema"
+      | "routes"
+      | "validator";
+  }>;
+
 export type ProofBinding = Readonly<{
   symbol_id: string;
   target: string;

package/src/public/proof-protocol.ts

@@ -70,8 +70,11 @@ export const SUCCESS_POLICIES = [
 /**
  * What a proof contract's checker establishes. Runner kinds (e2e, example,
  * property) sample cases and support tested evidence; certificate kinds
- * (exhaustive, typecheck, arithmetic, smt) cover every case and support
- * proved evidence once Kibi re-checks the certificate the run left.
+ * (exhaustive, typecheck, arithmetic, smt, rule, state_machine, regex,
+ * source) cover every case and support proved evidence once Kibi re-checks
+ * the certificate the run left. A source certificate is Kibi's own read of a
+ * project source (a JSON or YAML file, a glob, an OpenAPI document, the
+ * references the code makes, a data schema, a route table, a validator).
  */
 // implements REQ-kibi-code-proof-kinds
 export const PROOF_KINDS = [
@@ -82,14 +85,22 @@ export const PROOF_KINDS = [
   "typecheck",
   "arithmetic",
   "smt",
+  "rule",
+  "state_machine",
+  "regex",
+  "source",
 ] as const;
 
-// implements REQ-kibi-code-proof-kinds
+// implements REQ-kibi-code-proof-kinds, REQ-kibi-non-numeric-proof-kinds, REQ-kibi-source-proof-kinds
 export const CERTIFICATE_PROOF_KINDS = [
   "exhaustive",
   "typecheck",
   "arithmetic",
   "smt",
+  "rule",
+  "state_machine",
+  "regex",
+  "source",
 ] as const;
 
 // implements REQ-kibi-code-proof-kinds
@@ -127,6 +138,12 @@ import type {
   ProofResult,
   ProofRunArtifact,
 } from "./proof-protocol-types.js";
+import {
+  SOURCE_READERS,
+  type SourceSpec,
+  normalizeSourceSpec,
+  sourceSpecErrors,
+} from "./proof-sources.js";
 
 export const PROOF_RESULT_SCHEMA = {
   type: "object",
@@ -262,6 +279,57 @@ export const PROOF_RUN_ARTIFACT_SCHEMA = {
   additionalProperties: false,
 } as const;
 
+const SOURCE_REFERENCE_SCHEMA = {
+  type: "object",
+  required: ["symbol_id"],
+  properties: {
+    symbol_id: { type: "string", minLength: 1 },
+    export: { type: "string", minLength: 1 },
+  },
+  additionalProperties: false,
+} as const;
+
+// implements REQ-kibi-source-proof-kinds
+const SOURCE_SPEC_SCHEMA = {
+  type: "object",
+  description:
+    "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.",
+  required: ["reader"],
+  properties: {
+    reader: { type: "string", enum: [...SOURCE_READERS] },
+  },
+  additionalProperties: true,
+} as const;
+
+const SOURCE_DOMAIN_SCHEMA = {
+  type: "object",
+  required: ["source"],
+  properties: { source: SOURCE_SPEC_SCHEMA },
+  additionalProperties: false,
+} as const;
+
+const PREDICATE_SOURCE_SCHEMA = {
+  type: "object",
+  required: ["symbol_id"],
+  properties: {
+    symbol_id: { type: "string", minLength: 1 },
+    export: {
+      type: "string",
+      minLength: 1,
+      description:
+        "The exported function's name in the symbol's source file. Without it Kibi reads the export named by the symbol's title.",
+    },
+    harness_for: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string", minLength: 1 },
+      description:
+        "The predicate is a test harness that decides the predicate by driving these code symbols (for example by calling the handler with each role). The symbols must be covered_by the test; a claim the harness proves is bound with scope harness.",
+    },
+  },
+  additionalProperties: false,
+} as const;
+
 export const PROOF_CONTRACT_SCHEMA = {
   type: "object",
   description:
@@ -289,12 +357,16 @@ export const PROOF_CONTRACT_SCHEMA = {
       type: "string",
       enum: [...PROOF_KINDS],
       description:
-        "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic and smt must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved.",
+        "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.",
+    },
+    source: {
+      ...SOURCE_SPEC_SCHEMA,
+      description: `source: the project source a source proof reads. ${SOURCE_SPEC_SCHEMA.description}`,
     },
     domain_source: {
       type: "object",
       description:
-        "exhaustive and typecheck: the symbol that defines the finite domain. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.",
+        "exhaustive and typecheck: the symbol that defines the finite domain (typecheck: also the type whose fields a required_fields fact names). state_machine: the transition table or next-state function. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.",
       required: ["symbol_id"],
       properties: {
         symbol_id: { type: "string", minLength: 1 },
@@ -318,7 +390,7 @@ export const PROOF_CONTRACT_SCHEMA = {
     proves: {
       type: "array",
       description:
-        "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt); a claim with no such derivation is only attested and never counts as proved.",
+        "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt, a rule, predicate or set fact for rule and state_machine, a string fact for regex); a claim with no such derivation is only attested and never counts as proved.",
       minItems: 1,
       items: { type: "string", pattern: "^CLAIM-" },
       uniqueItems: true,
@@ -326,18 +398,50 @@ export const PROOF_CONTRACT_SCHEMA = {
     value_source: {
       type: "array",
       description:
-        "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base.",
+        "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).",
       minItems: 1,
       items: {
         type: "object",
-        required: ["symbol_id"],
         properties: {
           symbol_id: { type: "string", minLength: 1 },
           export: { type: "string", minLength: 1 },
+          source: SOURCE_SPEC_SCHEMA,
+          measure: {
+            type: "string",
+            enum: ["value", "count"],
+            description:
+              "value (default for an export): the export is a number. count (the only measure of a source): the number of members of a list, set, map or object export, or of a source.",
+          },
         },
         additionalProperties: false,
       },
     },
+    predicate_source: {
+      type: "object",
+      description:
+        "rule: the code function behind each predicate a claim's rule, predicate or set fact names, keyed by predicate name. Each export takes the predicate's arguments in order and returns a boolean; Kibi calls it on every combination of its argument domains.",
+      minProperties: 1,
+      additionalProperties: PREDICATE_SOURCE_SCHEMA,
+    },
+    domains: {
+      type: "object",
+      description:
+        "rule: the finite domain of each argument type, keyed by type name (an array, Set, Map or object export, or a Python list, set, dict or Enum), or {source} for the members Kibi reads from a project source (every route, every table, every environment variable). state_machine with a next-state function: the `state` and `event` domains it is called on.",
+      minProperties: 1,
+      additionalProperties: {
+        anyOf: [SOURCE_REFERENCE_SCHEMA, SOURCE_DOMAIN_SCHEMA],
+      },
+    },
+    initial_source: {
+      ...SOURCE_REFERENCE_SCHEMA,
+      description:
+        "state_machine: the export holding the initial state (or states), needed for initial_states and reachable_states facts.",
+    },
+    pattern_source: {
+      ...SOURCE_REFERENCE_SCHEMA,
+      description:
+        "regex: the export holding the code's pattern (a RegExp, or a Python re.Pattern) or string constant that a string fact is about.",
+    },
     constraint_source: {
       type: "object",
       description:
@@ -751,29 +855,55 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
     );
   const valueSource = contract.value_source;
   if (valueSource !== undefined) {
+    if (Array.isArray(valueSource))
+      valueSource.forEach((entry, index) => {
+        const row = record(entry);
+        if (row === null || row.source === undefined) return;
+        errors.push(
+          ...sourceSpecErrors(
+            row.source,
+            `proof_contract.value_source[${index}].source`,
+          ),
+        );
+        if (row.symbol_id !== undefined || row.export !== undefined)
+          errors.push(
+            `proof_contract.value_source[${index}] names a source, so it takes no symbol_id or export`,
+          );
+        if (row.measure !== undefined && row.measure !== "count")
+          errors.push(
+            `proof_contract.value_source[${index}].measure must be count for a source: Kibi counts the members it reads`,
+          );
+      });
     if (
       !Array.isArray(valueSource) ||
       valueSource.length === 0 ||
       !valueSource.every((entry) => {
         const row = record(entry);
+        if (row !== null && row.source !== undefined) return true;
         return (
           row !== null &&
           nonEmptyString(row.symbol_id) &&
           (row.export === undefined || nonEmptyString(row.export)) &&
+          (row.measure === undefined ||
+            row.measure === "value" ||
+            row.measure === "count") &&
           Object.keys(row).every(
-            (key) => key === "symbol_id" || key === "export",
+            (key) =>
+              key === "symbol_id" || key === "export" || key === "measure",
           )
         );
       })
     )
       errors.push(
-        "proof_contract.value_source must be [{symbol_id, export?}] naming the code constants the assumptions read",
+        "proof_contract.value_source must be [{symbol_id, export?, measure?: value|count} or {source, measure?: count}] naming the code constants or project sources the assumptions read",
       );
     else if (kind !== "arithmetic" && kind !== "smt")
       errors.push(
         `proof_contract.value_source applies only to kind arithmetic or smt, not ${String(kind ?? "e2e")}`,
       );
   }
+  errors.push(...nonNumericContractErrors(contract));
+  errors.push(...sourceContractErrors(contract));
   const proves = contract.proves;
   if (proves !== undefined) {
     if (
@@ -789,12 +919,164 @@ function proofContractKindErrors(contract: Record<string, unknown>): string[] {
       );
     else if (!isCertificateProofKind(kind))
       errors.push(
-        `proof_contract.proves applies only to certificate kinds (exhaustive, typecheck, arithmetic, smt), not ${String(kind ?? "e2e")}`,
+        `proof_contract.proves applies only to certificate kinds (${CERTIFICATE_PROOF_KINDS.join(", ")}), not ${String(kind ?? "e2e")}`,
       );
   }
   return errors;
 }
 
+function isSourceReference(value: unknown): boolean {
+  const row = record(value);
+  return (
+    row !== null &&
+    nonEmptyString(row.symbol_id) &&
+    (row.export === undefined || nonEmptyString(row.export)) &&
+    Object.keys(row).every((key) => key === "symbol_id" || key === "export")
+  );
+}
+
+function isSourceMap(
+  value: unknown,
+  accepts: (entry: unknown) => boolean = isSourceReference,
+): boolean {
+  const row = record(value);
+  return (
+    row !== null &&
+    Object.keys(row).length > 0 &&
+    Object.entries(row).every(
+      ([key, entry]) => key.trim() !== "" && accepts(entry),
+    )
+  );
+}
+
+function isPredicateReference(value: unknown): boolean {
+  const row = record(value);
+  if (row === null || row.harness_for === undefined)
+    return isSourceReference(value);
+  const { harness_for: harness, ...reference } = row;
+  return (
+    isSourceReference(reference) &&
+    Array.isArray(harness) &&
+    harness.length > 0 &&
+    harness.every(nonEmptyString)
+  );
+}
+
+function isSourceDomain(value: unknown): boolean {
+  const row = record(value);
+  return (
+    row !== null && Object.keys(row).length === 1 && row.source !== undefined
+  );
+}
+
+/**
+ * The source kind and the source-backed rule domains: a well-formed source
+ * spec, required for kind source and only there.
+ */
+// implements REQ-kibi-source-proof-kinds
+function sourceContractErrors(contract: Record<string, unknown>): string[] {
+  const errors: string[] = [];
+  const kind = contract.kind;
+  if (contract.source !== undefined) {
+    errors.push(...sourceSpecErrors(contract.source, "proof_contract.source"));
+    if (kind !== "source")
+      errors.push(
+        `proof_contract.source applies only to kind source, not ${String(kind ?? "e2e")}`,
+      );
+  } else if (kind === "source")
+    errors.push(
+      "proof_contract.source is required for kind source: name the project source Kibi reads (reader json, yaml, glob, openapi, references, schema, routes or validator)",
+    );
+  const domains = record(contract.domains);
+  for (const [type, entry] of Object.entries(domains ?? {}))
+    if (isSourceDomain(entry)) {
+      errors.push(
+        ...sourceSpecErrors(
+          record(entry)?.source,
+          `proof_contract.domains.${type}.source`,
+        ),
+      );
+      if (kind !== "rule")
+        errors.push(
+          `proof_contract.domains.${type}.source applies only to kind rule: a state machine's domains are the code's`,
+        );
+    }
+  return errors;
+}
+
+/**
+ * The contract fields of the rule, state_machine and regex kinds: where the
+ * code Kibi evaluates lives, and only on the kinds that read it.
+ */
+// implements REQ-kibi-non-numeric-proof-kinds
+function nonNumericContractErrors(contract: Record<string, unknown>): string[] {
+  const errors: string[] = [];
+  const kind = contract.kind;
+  const only = (field: string, kinds: readonly string[]) => {
+    if (contract[field] !== undefined && !kinds.includes(String(kind)))
+      errors.push(
+        `proof_contract.${field} applies only to kind ${kinds.join(" or ")}, not ${String(kind ?? "e2e")}`,
+      );
+  };
+  if (
+    contract.predicate_source !== undefined &&
+    !isSourceMap(contract.predicate_source, isPredicateReference)
+  )
+    errors.push(
+      "proof_contract.predicate_source must map each predicate name to {symbol_id, export?, harness_for?} naming the function that decides it",
+    );
+  if (
+    contract.domains !== undefined &&
+    !isSourceMap(
+      contract.domains,
+      (entry) => isSourceReference(entry) || isSourceDomain(entry),
+    )
+  )
+    errors.push(
+      "proof_contract.domains must map each argument type to {symbol_id, export?} naming the export that lists its values, or {source} naming the project source Kibi reads them from",
+    );
+  for (const field of ["initial_source", "pattern_source"])
+    if (contract[field] !== undefined && !isSourceReference(contract[field]))
+      errors.push(
+        `proof_contract.${field} must be {symbol_id, export?} naming the export Kibi reads`,
+      );
+  only("predicate_source", ["rule"]);
+  only("domains", ["rule", "state_machine"]);
+  only("initial_source", ["state_machine"]);
+  only("pattern_source", ["regex"]);
+  if (kind === "rule") {
+    if (contract.predicate_source === undefined)
+      errors.push(
+        "proof_contract.predicate_source is required for kind rule: name the function behind each predicate the claims use",
+      );
+    if (contract.domains === undefined)
+      errors.push(
+        "proof_contract.domains is required for kind rule: name the export listing each argument type's values",
+      );
+  }
+  if (kind === "state_machine") {
+    if (contract.domain_source === undefined)
+      errors.push(
+        "proof_contract.domain_source is required for kind state_machine: name the transition table or next-state function",
+      );
+    const domains = record(contract.domains);
+    if (
+      domains !== null &&
+      (Object.keys(domains).length !== 2 ||
+        domains.state === undefined ||
+        domains.event === undefined)
+    )
+      errors.push(
+        "proof_contract.domains for kind state_machine must name exactly the state and event domains a next-state function is called on",
+      );
+  }
+  if (kind === "regex" && contract.pattern_source === undefined)
+    errors.push(
+      "proof_contract.pattern_source is required for kind regex: name the export holding the pattern or string",
+    );
+  return errors;
+}
+
 /**
  * The optional contract fields beyond the v1 core, copied only when present
  * so existing contracts keep their hash.
@@ -810,14 +1092,24 @@ export function optionalProofContractFields(
   | "constraint_source"
   | "value_source"
   | "proves"
+  | "predicate_source"
+  | "domains"
+  | "initial_source"
+  | "pattern_source"
+  | "source"
 > {
   const fields: {
     kind?: ProofKind;
     domain_source?: { symbol_id: string; export?: string };
     witness?: { path: string };
     constraint_source?: { fact_ids: string[] };
-    value_source?: { symbol_id: string; export?: string }[];
+    value_source?: ValueSourceEntry[];
     proves?: string[];
+    predicate_source?: Record<string, PredicateReference>;
+    domains?: Record<string, SourceReference | { source: SourceSpec }>;
+    initial_source?: SourceReference;
+    pattern_source?: SourceReference;
+    source?: SourceSpec;
   } = {};
   if (typeof contract.kind === "string")
     fields.kind = contract.kind as ProofKind;
@@ -840,21 +1132,105 @@ export function optionalProofContractFields(
   if (Array.isArray(contract.value_source))
     fields.value_source = contract.value_source
       .map((entry) => record(entry))
-      .filter(
-        (row): row is Record<string, unknown> =>
-          row !== null && typeof row.symbol_id === "string",
-      )
-      .map((row) => ({
-        symbol_id: String(row.symbol_id),
-        ...(typeof row.export === "string" ? { export: row.export } : {}),
-      }));
+      .map((row): ValueSourceEntry | null => {
+        if (row === null) return null;
+        const spec = normalizeSourceSpec(row.source);
+        if (spec !== undefined) return { source: spec, measure: "count" };
+        if (typeof row.symbol_id !== "string") return null;
+        return {
+          symbol_id: row.symbol_id,
+          ...(typeof row.export === "string" ? { export: row.export } : {}),
+          ...(row.measure === "value" || row.measure === "count"
+            ? { measure: row.measure }
+            : {}),
+        };
+      })
+      .filter((row): row is ValueSourceEntry => row !== null);
   if (Array.isArray(contract.proves))
     fields.proves = contract.proves.filter(
       (key): key is string => typeof key === "string",
     );
+  const predicates = predicateMap(contract.predicate_source);
+  if (predicates !== undefined) fields.predicate_source = predicates;
+  const domains = domainMap(contract.domains);
+  if (domains !== undefined) fields.domains = domains;
+  const spec = normalizeSourceSpec(contract.source);
+  if (spec !== undefined) fields.source = spec;
+  const initial = sourceReference(contract.initial_source);
+  if (initial !== undefined) fields.initial_source = initial;
+  const pattern = sourceReference(contract.pattern_source);
+  if (pattern !== undefined) fields.pattern_source = pattern;
   return fields;
 }
 
+type SourceReference = { symbol_id: string; export?: string };
+type PredicateReference = SourceReference & { harness_for?: string[] };
+type ValueSourceEntry =
+  | { symbol_id: string; export?: string; measure?: "value" | "count" }
+  | { source: SourceSpec; measure: "count" };
+
+function predicateMap(
+  value: unknown,
+): Record<string, PredicateReference> | undefined {
+  const row = record(value);
+  if (!row) return undefined;
+  const out: Record<string, PredicateReference> = {};
+  for (const [key, entry] of Object.entries(row)) {
+    const reference = sourceReference(entry);
+    if (reference === undefined) continue;
+    const harness = record(entry)?.harness_for;
+    out[key] = Array.isArray(harness)
+      ? {
+          ...reference,
+          harness_for: harness.filter(
+            (id): id is string => typeof id === "string",
+          ),
+        }
+      : reference;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function domainMap(
+  value: unknown,
+): Record<string, SourceReference | { source: SourceSpec }> | undefined {
+  const row = record(value);
+  if (!row) return undefined;
+  const out: Record<string, SourceReference | { source: SourceSpec }> = {};
+  for (const [key, entry] of Object.entries(row)) {
+    const spec = normalizeSourceSpec(record(entry)?.source);
+    if (spec !== undefined) {
+      out[key] = { source: spec };
+      continue;
+    }
+    const reference = sourceReference(entry);
+    if (reference !== undefined) out[key] = reference;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function sourceReference(value: unknown): SourceReference | undefined {
+  const row = record(value);
+  if (!row || typeof row.symbol_id !== "string") return undefined;
+  return {
+    symbol_id: row.symbol_id,
+    ...(typeof row.export === "string" ? { export: row.export } : {}),
+  };
+}
+
+function sourceMap(
+  value: unknown,
+): Record<string, SourceReference> | undefined {
+  const row = record(value);
+  if (!row) return undefined;
+  const out: Record<string, SourceReference> = {};
+  for (const [key, entry] of Object.entries(row)) {
+    const reference = sourceReference(entry);
+    if (reference !== undefined) out[key] = reference;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
 export function proofBindingsErrors(value: unknown): string[] {
   if (!Array.isArray(value))
     return ["proof_bindings must be an array of binding objects"];

package/src/public/proof-receipt.ts

@@ -183,7 +183,10 @@ export const PROOF_RECEIPT_SCHEMA = {
             type: "string",
             enum: [...CLAIM_BINDING_VERDICTS],
           },
-          scope: { type: "string", enum: ["code", "intent"] },
+          scope: {
+            type: "string",
+            enum: ["code", "source", "harness", "intent"],
+          },
           obligation: { type: "object" },
           reason: { type: "string", minLength: 1 },
         },
@@ -265,7 +268,8 @@ export type ClaimBinding = Readonly<{
   requirement_id?: string;
   fact_id?: string;
   binding: ClaimBindingVerdict;
-  scope?: "code" | "intent";
+  /** What the proof rests on: evaluated code, project files Kibi read (source), a test harness, or the knowledge base alone (intent). */
+  scope?: "code" | "source" | "harness" | "intent";
   obligation?: Readonly<Record<string, unknown>>;
   reason?: string;
 }>;
@@ -471,6 +475,8 @@ function validClaimBindings(value: unknown): boolean {
         ) &&
         (entry.scope === undefined ||
           entry.scope === "code" ||
+          entry.scope === "source" ||
+          entry.scope === "harness" ||
           entry.scope === "intent") &&
         (entry.obligation === undefined || isRecord(entry.obligation)) &&
         (entry.reason === undefined || nonEmptyString(entry.reason)),