@wowok/agent-mcp 3.4.3 → 3.4.4

package/dist/knowledge/baselines/rules/progress.json.good

@@ -0,0 +1,364 @@
+{
+  "comment": "Progress rule pack (R-PR) — declarative form of the retired in-code Progress risk rules. Facts are produced by the kernel extractor (progress-risk.ts, bound to the on-chain count limits and the Machine/Order/Repository cross-object semantics); rules only reference fact names. Levels/wording can be retuned per rule and rules can be disabled (enabled=false, trace left) via the judgment document — factory rules can never be deleted or invented here. R-PR-5-01 ships disabled: its E_ORDER_NOT_MATCH check needs an Order query and is left to the confirmation layer (the retired in-code check was a no-op).",
+  "facts": {
+    "named_operator_addr_count": "Address count of the progress_namedOperator op's operator list.",
+    "named_operator_name": "The named_operator name targeted by the op (display form).",
+    "max_named_operator_address_count": "KERNEL CONSTANT — on-chain MAX_NAMED_OPERATOR_ADDRESS_COUNT bound imported from @wowok/wowok.",
+    "named_operator_addr_count_exceeded": "True when the op's address list exceeds MAX_NAMED_OPERATOR_ADDRESS_COUNT (E_MAX_NAMED_OPERATOR_ADDRESS_COUNT ahead).",
+    "named_operator_count_current": "Current named-operator namespace count on the Progress (0 when unknown).",
+    "max_named_operator_count": "KERNEL CONSTANT — on-chain MAX_NAMED_OPERATOR_COUNT bound imported from @wowok/wowok.",
+    "named_operator_count_at_limit": "True when an 'add' op lands on a Progress already at MAX_NAMED_OPERATOR_COUNT (E_MAX_NAMED_OPERATOR_COUNT ahead).",
+    "context_repo_current": "Current context repository count on the Progress (0 when unknown).",
+    "context_repo_add_count": "Repositories the op would add (0 for remove; the clear op is not a candidate).",
+    "context_repo_total": "Projected repository count after the op.",
+    "max_context_repository_count": "KERNEL CONSTANT — on-chain MAX_CONTEXT_REPOSITORY_COUNT bound imported from @wowok/wowok.",
+    "context_repo_count_exceeded": "True when the projected repository count exceeds MAX_CONTEXT_REPOSITORY_COUNT (E_MAX_CONTEXT_REPOSITORY_COUNT ahead).",
+    "named_operator_empty_name": "True when a non-remove named_operator op targets the empty-string name — the reserved OrderHolder namespace.",
+    "task_submit_blocked": "True when a task submission targets a Progress that already has a task bound (E_TASK_ALREADY_SET ahead).",
+    "current_task_display": "The currently bound task (Order) object id (display form).",
+    "operate_message_over_long": "True when operate.message exceeds the 1024-char common::LONG_NAME bound.",
+    "operate_message_length": "Length of operate.message in characters.",
+    "operate_op_invalid": "True when operate.op is set but not one of next/hold/unhold/adminUnhold.",
+    "operate_op": "The operate.op value (display form).",
+    "admin_unhold_op": "True when operate.op is 'adminUnhold' (224-permission force release).",
+    "operate_forward": "The forward name the operate op advances (display form).",
+    "operate_next_node_name": "The target node name of the operate op (display form).",
+    "forward_named_operator": "The namedOperator governing the forward being advanced (echo).",
+    "forward_named_op_bypass": "True when the forward advance rides the namedOperator short-circuit, skipping the 220-225 permission-index check.",
+    "forward_payer_scope": "True when the forward being advanced has namedOperator=\"\" (the reserved order-payer namespace) — payer-only authority: off the order-bound entry the advance asserts order-payer power, and a taskless Progress fails closed earlier (E_ORDER_TASK_REQUIRED — C-F06 split, the task assert precedes the payer check).",
+    "forward_has_guard_display": "Echo of whether the forward carries a Guard (display form).",
+    "guard_passport_required": "True when the forward has a Guard but no permission index — a Passport is required for the advance (E_NEED_PASSPORT ahead).",
+    "machine_published_false": "True when the context explicitly marks the Machine as unpublished (strict false).",
+    "machine_name": "The Machine object id the Progress binds to (raw echo, display form).",
+    "machine_name_or_unknown": "The Machine object id, or '(unknown)' when absent (description display form).",
+    "forward_reaccomplish": "True when an operate targets a forward that is already accomplished (E_FORWARD_ALREADY_ACCOMPLISHED ahead).",
+    "unhold_non_holder": "True when an 'unhold' op is signed by an address other than the current holder (E_NOT_THE_HOLDER ahead).",
+    "holder_display": "The address currently holding the forward (display form).",
+    "signer_display": "The address signing the operate op (display form).",
+    "repository_add_op": "True when the context carries a repository 'add' op (creates object-linker tx bindings).",
+    "repo_add_count": "Number of repositories the 'add' op introduces.",
+    "heterogeneous_host_types": "True when the target object types span more than one distinct host type (≥2 entries).",
+    "unique_target_types_csv_space": "Distinct target host types, comma-space-joined (description display form).",
+    "unique_target_types_csv": "Distinct target host types, comma-joined (evidence display form).",
+    "orderless_operate": "True when an operate targets a Progress with no bound task (task=null) — order-holder advance/hold unavailable (E_ORDER_NOT_MATCH)."
+  },
+  "rules": [
+    {
+      "rule_id": "R-PR-1-01",
+      "dimension": "structural",
+      "trigger": "named_operator addresses count > MAX_NAMED_OPERATOR_ADDRESS_COUNT (80)",
+      "cases": [
+        {
+          "when": { "field": "named_operator_addr_count_exceeded", "op": "eq", "value": true },
+          "level": "high",
+          "title": "named_operator address count exceeds limit",
+          "description": "named_operator \"${named_operator_name}\" has ${named_operator_addr_count} addresses, exceeds MAX_NAMED_OPERATOR_ADDRESS_COUNT ${max_named_operator_address_count}. Move aborts with E_MAX_NAMED_OPERATOR_ADDRESS_COUNT.",
+          "scenario": "Adding > 80 addresses to a single named operator",
+          "mitigation": "Split into multiple named_operator names, or remove inactive addresses first",
+          "evidence": "addr_count=${named_operator_addr_count}",
+          "stakeholders": ["owner", "named_operator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-1-02",
+      "dimension": "structural",
+      "trigger": "Adding new named_operator would exceed MAX_NAMED_OPERATOR_COUNT (60)",
+      "cases": [
+        {
+          "when": { "field": "named_operator_count_at_limit", "op": "eq", "value": true },
+          "level": "high",
+          "title": "named_operator namespace count at limit",
+          "description": "Progress already has ${named_operator_count_current} named operators, at MAX_NAMED_OPERATOR_COUNT ${max_named_operator_count}. Adding a new name will abort with E_MAX_NAMED_OPERATOR_COUNT.",
+          "scenario": "Adding a 61st named_operator name to a full Progress",
+          "mitigation": "Use 'set' on an existing name (replace address list), or remove an unused name first",
+          "evidence": "named_operator_count=${named_operator_count_current}",
+          "stakeholders": ["owner"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-1-03",
+      "dimension": "structural",
+      "trigger": "context_repository add would exceed MAX_CONTEXT_REPOSITORY_COUNT (30)",
+      "cases": [
+        {
+          "when": { "field": "context_repo_count_exceeded", "op": "eq", "value": true },
+          "level": "high",
+          "title": "context_repository count exceeds limit",
+          "description": "Progress has ${context_repo_current} repositories, adding ${context_repo_add_count} would total ${context_repo_total}, exceeds MAX_CONTEXT_REPOSITORY_COUNT ${max_context_repository_count}. Move aborts with E_MAX_CONTEXT_REPOSITORY_COUNT.",
+          "scenario": "Adding too many context repositories",
+          "mitigation": "Remove unused repositories first, or use repository 'set' to replace the list",
+          "evidence": "current=${context_repo_current}, add=${context_repo_add_count}",
+          "stakeholders": ["owner"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-1-04",
+      "dimension": "structural",
+      "trigger": "named_operator name is empty string but is_order_holder_namespace=false",
+      "cases": [
+        {
+          "when": { "field": "named_operator_empty_name", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "named_operator name is empty (OrderHolder namespace)",
+          "description": "progress_namedOperator.name=\"\" — empty string maps to the OrderHolder namespace (the reserved no-name operator slot). This is typically set automatically when an Order is created through the buy flow, not by direct user op. Manual manipulation may overwrite order-payer authorization.",
+          "scenario": "User manually setting the empty-name namespace",
+          "mitigation": "If intentional (e.g. an internal order-ownership call), confirm. Otherwise use a non-empty name.",
+          "evidence": "name=\"\"",
+          "stakeholders": ["owner", "named_operator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-2-01",
+      "dimension": "semantic",
+      "trigger": "task submission on a Progress that already has a task (E_TASK_ALREADY_SET)",
+      "cases": [
+        {
+          "when": { "field": "task_submit_blocked", "op": "eq", "value": true },
+          "level": "high",
+          "title": "Task already bound on this Progress (irreversible)",
+          "description": "Progress already has task=${current_task_display}. Task submission is one-time; Move aborts with E_TASK_ALREADY_SET. There is no way to change the task after first set.",
+          "scenario": "User tries to rebind Progress to a different Order",
+          "mitigation": "Create a new Progress through a new buy flow with the new Order; the old Progress is permanently bound",
+          "evidence": "current_task=${current_task_display}",
+          "stakeholders": ["owner", "submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-2-02",
+      "dimension": "semantic",
+      "trigger": "operate.message exceeds MAX_LONG_NAME_LENGTH (long-name constraint)",
+      "cases": [
+        {
+          "when": { "field": "operate_message_over_long", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "operate.message exceeds long-name length",
+          "description": "operate.message length ${operate_message_length} exceeds MAX_LONG_NAME_LENGTH (1024). Move aborts in common::LONG_NAME check.",
+          "scenario": "Long deliverable message",
+          "mitigation": "Truncate message to ≤ 1024 chars; store full payload in a context Repository",
+          "evidence": "msg_len=${operate_message_length}",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-2-03",
+      "dimension": "semantic",
+      "trigger": "operate.op is not a valid enum value (schema-enforced, defense-in-depth)",
+      "cases": [
+        {
+          "when": { "field": "operate_op_invalid", "op": "eq", "value": true },
+          "level": "high",
+          "title": "operate.op must be one of: next, hold, unhold, adminUnhold",
+          "description": "op enum selects the Move function: next=accomplish, hold=hold(bHold=true), unhold=hold(bHold=false), adminUnhold=unhold (224 permission).",
+          "scenario": "Schema validation bypassed or stale client",
+          "mitigation": "Use one of: next, hold, unhold, adminUnhold",
+          "evidence": "op=${operate_op}",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-3-01",
+      "dimension": "permission",
+      "trigger": "op='adminUnhold' (224 permission) — force release bypassing holder check",
+      "cases": [
+        {
+          "when": { "field": "admin_unhold_op", "op": "eq", "value": true },
+          "level": "high",
+          "title": "adminUnhold bypasses holder check (broad blast radius)",
+          "description": "adminUnhold uses 224 permission to release a held forward WITHOUT verifying sender == holder. If 224 is granted too broadly, any 224-holder can release ANY held forward in this Progress.",
+          "scenario": "Admin force-releases a forward that the original holder still wanted held",
+          "mitigation": "1) Grant 224 only to dedicated recovery addresses. 2) Log every adminUnhold for audit. 3) Prefer normal unhold (holder self-release) when possible.",
+          "evidence": "adminUnhold=true, forward=${operate_forward}",
+          "stakeholders": ["owner", "named_operator", "submitter"],
+          "exposure": {
+            "loss_parties": [
+              { "role": "buyer", "basis": "A hold is the objection brake on a disputed delivery; a forced release lets the workflow advance past it toward the terminal allocation despite the objection." }
+            ],
+            "gain_paths": [
+              {
+                "role": "neutral",
+                "path": "A broad 224-grantee force-releases the blocking hold and the workflow proceeds to the allocation the hold was placed to stop.",
+                "viability": "conditional",
+                "gate": "Executes only when the 224 permission is granted beyond dedicated recovery addresses — the rule flags grant breadth, not an observed over-grant."
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-3-02",
+      "dimension": "permission",
+      "trigger": "namedOperator short-circuit bypasses 220-225 permission check",
+      "cases": [
+        {
+          "when": { "field": "forward_named_op_bypass", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "Forward advance via named_operator short-circuits 220-225 check",
+          "description": "Forward \"${operate_forward}\" uses namedOperator=\"${forward_named_operator}\". Move's ASSERT_PERMISSION returns immediately if IsNamedOperator() succeeds, WITHOUT checking any permission index. Anyone in the named_operator list can advance this forward.",
+          "scenario": "Operator list too permissive (e.g. includes expired/compromised addresses)",
+          "mitigation": "1) Keep named_operator lists minimal. 2) Use namedOperator_remove to revoke access promptly. 3) For sensitive forwards, prefer Forward.permissionIndex (Some) for dual-check.",
+          "evidence": "named_operator=${forward_named_operator}",
+          "stakeholders": ["owner", "named_operator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-3-03",
+      "dimension": "permission",
+      "trigger": "Forward has guard (Some) — Passport required but not provided",
+      "cases": [
+        {
+          "when": { "field": "guard_passport_required", "op": "eq", "value": true },
+          "level": "high",
+          "title": "Forward guard requires Passport",
+          "description": "Forward \"${operate_forward}\" has a guard (Some). The advance asserts E_NEED_PASSPORT for guarded forwards when called without a passport. Use the passport-bearing advance path (progress-level or order-holder) instead.",
+          "scenario": "User calls next() on a guarded forward without passport",
+          "mitigation": "Submit via *_with_passport variant; ensure submission data is valid for the Guard",
+          "evidence": "forward=${operate_forward}, has_guard=${forward_has_guard_display}",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-3-04",
+      "dimension": "permission",
+      "trigger": "Forward namedOperator=\"\" (order-payer namespace) — payer-only authority; taskless fail-closed (E_ORDER_TASK_REQUIRED)",
+      "cases": [
+        {
+          "when": { "field": "forward_payer_scope", "op": "eq", "value": true },
+          "level": "high",
+          "title": "Forward names the order payer — generic-entry advance aborts E_ORDER_PAYER_REQUIRED",
+          "description": "Forward \"${operate_forward}\" has namedOperator=\"\" — the reserved order-payer namespace. Only the payer of the bound Order (or an address holding op-permission on that Order) may drive it: generic entries (next/hold, with or without passport) assert payer authority and abort with E_ORDER_PAYER_REQUIRED otherwise; a taskless Progress (task=null) fails closed earlier with E_ORDER_TASK_REQUIRED (C-F06 split — no payer exists to name, so the forward is un-executable by design).",
+          "scenario": "An operator presses a buyer-owned (order-payer) edge from a generic entry, or a standalone machine is designed with \"\" forwards",
+          "mitigation": "Drive the step as the order payer via the order-bound path (the SDK auto-routes progress.operate to the order entries when the task is an Order), or grant the address op-permission on the bound Order. For standalone Progress workflows, declare forwards with a non-empty namedOperator or a permissionIndex instead of \"\".",
+          "evidence": "named_operator=\"\", forward=${operate_forward}",
+          "stakeholders": ["submitter", "owner"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-4-01",
+      "dimension": "lifecycle",
+      "trigger": "Machine not published — Progress cannot be created",
+      "cases": [
+        {
+          "when": { "field": "machine_published_false", "op": "eq", "value": true },
+          "level": "critical",
+          "title": "Machine not published — Progress creation blocked",
+          "description": "Machine ${machine_name_or_unknown} is not published. Progress requires a published Machine (creation asserts the published state). All Progress ops will fail with E_MACHINE_NOT_MATCH or similar.",
+          "scenario": "User attempts to create Progress before Machine publish",
+          "mitigation": "Publish the Machine first (205 permission), then create Progress",
+          "evidence": "machine=${machine_name}, published=false",
+          "stakeholders": ["owner"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-4-02",
+      "dimension": "lifecycle",
+      "trigger": "operate on already-accomplished forward (E_FORWARD_ALREADY_ACCOMPLISHED)",
+      "cases": [
+        {
+          "when": { "field": "forward_reaccomplish", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "Forward already accomplished — re-hold blocked",
+          "description": "Forward \"${operate_forward}\" to \"${operate_next_node_name}\" is already accomplished. Move aborts with E_FORWARD_ALREADY_ACCOMPLISHED on any re-hold attempt.",
+          "scenario": "User retries an already-completed forward (race condition or stale state)",
+          "mitigation": "Query Progress.current — if already past target, no action needed; if parallel session, use a different forward",
+          "evidence": "forward=${operate_forward}, accomplished=true",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-4-03",
+      "dimension": "lifecycle",
+      "trigger": "unhold by non-holder without 224 permission (E_NOT_THE_HOLDER)",
+      "cases": [
+        {
+          "when": { "field": "unhold_non_holder", "op": "eq", "value": true },
+          "level": "high",
+          "title": "unhold by non-holder — Move will abort E_NOT_THE_HOLDER",
+          "description": "Forward is held by ${holder_display}, but signer is ${signer_display}. Move aborts with E_NOT_THE_HOLDER unless signer has 224 permission (adminUnhold path).",
+          "scenario": "User other than holder tries to release a hold",
+          "mitigation": "1) Have the original holder call unhold. 2) If holder is unresponsive, use adminUnhold=true (requires 224).",
+          "evidence": "holder=${holder_display}, signer=${signer_display}",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-5-01",
+      "dimension": "cross_object",
+      "trigger": "order-holder advance called but progress.task != order address (E_ORDER_NOT_MATCH)",
+      "enabled": false,
+      "cases": [
+        {
+          "when": { "field": "always_true", "op": "eq", "value": false },
+          "level": "low",
+          "title": "order-holder advance without a matching bound Order (retired-inert)",
+          "description": "R-PR-5-01 is retired-inert in the factory pack (enabled=false): the E_ORDER_NOT_MATCH check needs an Order query that the pack-level context cannot perform, so it is left to the confirmation layer — mirroring the retired in-code check, which never fired. Re-enabling cannot make this case fire (its guard is unsatisfiable by design).",
+          "mitigation": "Full check requires querying Order — done at the confirmation layer."
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-5-02",
+      "dimension": "cross_object",
+      "trigger": "context repository add without object-linker tx binding check",
+      "cases": [
+        {
+          "when": { "field": "repository_add_op", "op": "eq", "value": true },
+          "level": "low",
+          "title": "Context repository add creates object-linker tx binding",
+          "description": "Adding ${repo_add_count} repository(ies) creates object-linker tx binding entries. If the Repository is later deleted through a disaffiliation transaction, cross-object queries that depend on it will return empty results without warning.",
+          "scenario": "Repository deleted while Progress still references it",
+          "mitigation": "Remove the context repository binding before deleting a Repository; audit object-linker bindings periodically",
+          "evidence": "add_count=${repo_add_count}",
+          "stakeholders": ["owner", "system"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-5-03",
+      "dimension": "cross_object",
+      "trigger": "Permission used by Progress is shared with other host objects",
+      "cases": [
+        {
+          "when": { "field": "heterogeneous_host_types", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "Permission shared across heterogeneous host objects",
+          "description": "Single Permission applied to ${unique_target_types_csv_space}. Progress builtin indexes (220-225) have different semantics per host object; granting 221 (PROGRESS_NAMED_OPERATOR) to a non-Progress entity is meaningless.",
+          "scenario": "One Permission for both Progress and Machine",
+          "mitigation": "Use separate Permission objects per host object type",
+          "evidence": "types=${unique_target_types_csv}",
+          "stakeholders": ["owner"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PR-5-04",
+      "dimension": "cross_object",
+      "trigger": "Progress without bound Order (order=null) — order-holder advance/hold blocked",
+      "cases": [
+        {
+          "when": { "field": "orderless_operate", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "operate without bound Order — order-holder advance/hold unavailable",
+          "description": "Progress has no bound task (task=null). The order-holder advance and hold paths require progress.task == order address (E_ORDER_NOT_MATCH). Use plain next()/hold() instead — except for forwards with namedOperator=\"\": with no bound Order there is no payer to name, so those abort fail-closed (E_ORDER_TASK_REQUIRED, C-F06 split) on any entry.",
+          "scenario": "User tries order variant on a task-less Progress",
+          "mitigation": "Use non-order next()/hold() variant (non-empty-namedOperator or permissionIndex forwards), OR submit the task first to bind an Order; \"\"-scoped forwards on a taskless Progress are un-executable by design",
+          "evidence": "task=null",
+          "stakeholders": ["submitter"]
+        }
+      ]
+    }
+  ]
+}

package/dist/knowledge/baselines/rules/proof.json.good

@@ -0,0 +1,158 @@
+{
+  "comment": "Proof rule pack (R-PROOF) — declarative form of the retired in-code Proof risk rules. Facts are produced by the kernel extractor (proof-risk.ts, bound to the on-chain proof/pubkey/signature size limits and the reserved proof_type range); rules only reference fact names. Levels/wording can be retuned per rule and rules can be disabled (enabled=false, trace left) via the judgment document — factory rules can never be deleted or invented here. R-PROOF-07 stays LAST in the array: it is the unconditional immutability reminder the retired check appended after every evaluation.",
+  "facts": {
+    "proof_length": "Length of the 'proof' content string, passed through for evidence text.",
+    "proof_size_exceeded": "True when a non-empty proof content exceeds the chain proof size limit.",
+    "server_pubkey_length": "Length of the server_pubkey string, passed through for evidence text.",
+    "server_pubkey_size_exceeded": "True when a non-empty server_pubkey exceeds the chain pubkey size limit.",
+    "server_signature_length": "Length of the server_signature string, passed through for evidence text.",
+    "server_signature_size_exceeded": "True when a non-empty server_signature exceeds the chain signature size limit.",
+    "proof_type": "Raw proof_type value (number / bigint / numeric string), passed through for evidence text.",
+    "proof_type_reserved": "True when proof_type is provided, is not the WTS type, and falls in the Wowok-reserved 2-100 range.",
+    "about_address": "Raw about_address value — falsy (null/undefined/empty) means the Proof has no on-chain binding.",
+    "description_empty": "True when description is provided but is the empty string.",
+    "constants_synced": "True when the proof constants are in sync with the published chain constants (false = knowledge-layer regression).",
+    "always_true": "Unconditional marker fact — rules that fire for every evaluation reference it.",
+    "max_proof_size": "KERNEL CONSTANT — maximum proof content size in bytes.",
+    "max_server_pubkey_size": "KERNEL CONSTANT — maximum server_pubkey size in bytes.",
+    "max_server_signature_size": "KERNEL CONSTANT — maximum server_signature size in bytes.",
+    "wowok_wts_proof_type": "KERNEL CONSTANT — the proof_type value reserved for Will-To-Sign (WTS) proofs."
+  },
+  "rules": [
+    {
+      "rule_id": "R-PROOF-01",
+      "dimension": "structural",
+      "trigger": "proof content exceeds the chain proof size limit",
+      "cases": [
+        {
+          "when": { "field": "proof_size_exceeded", "op": "eq", "value": true },
+          "level": "high",
+          "title": "proof content exceeds MAX_PROOF_SIZE (${max_proof_size} bytes)",
+          "description": "The 'proof' string field is bounded by MAX_PROOF_SIZE=${max_proof_size} bytes. Exceeding this limit aborts with E_MAX_PROOF_SIZE (1). The proof content typically holds a merkle tree root or similar compact cryptographic digest — large data should be stored in a Repository and referenced by address, not inlined into the Proof object.",
+          "scenario": "Caller submits a proof string longer than 10240 bytes",
+          "mitigation": "Keep proof content compact (merkle root, hash digest). For larger payloads, store data in a Repository object and set about_address to the Repository address, or use item_count to indicate the off-chain data size.",
+          "evidence": "proof.length=${proof_length}, limit=${max_proof_size}",
+          "stakeholders": ["creator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-02",
+      "dimension": "structural",
+      "trigger": "server_pubkey exceeds the chain pubkey size limit",
+      "cases": [
+        {
+          "when": { "field": "server_pubkey_size_exceeded", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "server_pubkey exceeds MAX_SERVER_PUBKEY_SIZE (${max_server_pubkey_size} bytes)",
+          "description": "The 'server_pubkey' field is bounded by MAX_SERVER_PUBKEY_SIZE=${max_server_pubkey_size} bytes. Exceeding this limit aborts with E_MAX_SERVER_PUBKEY_SIZE (2). Typical public keys (Ed25519=32 bytes, RSA-2048=256 bytes, BLS12-381 G1=48 bytes, G2=96 bytes) fit comfortably within this limit.",
+          "scenario": "Caller submits an oversized server public key (e.g. certificate chain instead of raw key)",
+          "mitigation": "Submit only the raw public key bytes (hex-encoded), not a full certificate or JWK structure.",
+          "evidence": "server_pubkey.length=${server_pubkey_length}, limit=${max_server_pubkey_size}",
+          "stakeholders": ["creator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-03",
+      "dimension": "structural",
+      "trigger": "server_signature exceeds the chain signature size limit",
+      "cases": [
+        {
+          "when": { "field": "server_signature_size_exceeded", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "server_signature exceeds MAX_SERVER_SIGNATURE_SIZE (${max_server_signature_size} bytes)",
+          "description": "The 'server_signature' field is bounded by MAX_SERVER_SIGNATURE_SIZE=${max_server_signature_size} bytes. Exceeding this limit aborts with E_MAX_SERVER_SIGNATURE_SIZE (3). Most signature schemes produce signatures well under this limit (Ed25519=64 bytes, ECDSA=64-72 bytes, BLS12-381=96 bytes, RSA-2048=256 bytes).",
+          "scenario": "Caller submits an oversized signature (e.g. bundled with metadata)",
+          "mitigation": "Submit only the raw signature bytes (hex-encoded), not bundled metadata or certificate chains.",
+          "evidence": "server_signature.length=${server_signature_length}, limit=${max_server_signature_size}",
+          "stakeholders": ["creator"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-04",
+      "dimension": "semantic",
+      "trigger": "proof_type falls in the Wowok-reserved 2-100 range without authority",
+      "cases": [
+        {
+          "when": { "field": "proof_type_reserved", "op": "eq", "value": true },
+          "level": "medium",
+          "title": "proof_type in reserved range without authority (1-100 reserved for Wowok)",
+          "description": "proof_type=${wowok_wts_proof_type} is WOWOK_WTS_PROOF_TYPE (Will-To-Sign). Values 2-100 are reserved for future Wowok-defined proof types. User-defined proof types must use values > 100. While the Move contract does not currently enforce this range at the type level (it accepts any u64), using a reserved value without authority creates semantic confusion: consumers may misinterpret the proof's verification rules.",
+          "scenario": "User creates a custom proof with proof_type=5 (a reserved value)",
+          "mitigation": "Use proof_type > 100 for user-defined proof types. Use proof_type=1 only for WTS proofs signed by an off-chain server (with server_pubkey + server_signature). Document the verification rule for custom types.",
+          "evidence": "proof_type=${proof_type} (reserved range 2-100)",
+          "stakeholders": ["creator", "consumer", "verifier"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-05",
+      "dimension": "semantic",
+      "trigger": "about_address left null/undefined",
+      "cases": [
+        {
+          "when": { "field": "about_address", "op": "falsy" },
+          "level": "low",
+          "title": "about_address not provided — consumers cannot locate the referenced entity",
+          "description": "about_address is the on-chain address of the entity being proved (e.g. a user, an order, a Repository). When null/undefined, the Proof has no on-chain binding — it is a free-standing cryptographic statement. Consumers (Repository, Service, etc.) that reference this Proof cannot automatically resolve which entity it applies to. This is acceptable for generic proofs but problematic for entity-bound attestations.",
+          "scenario": "Caller creates a Proof without about_address, then a Repository tries to bind it to a data entry",
+          "mitigation": "Set about_address when the Proof attests to a specific on-chain entity. Leave it null only for free-standing cryptographic statements (e.g. a server's timestamp attestation).",
+          "evidence": "about_address=null/undefined",
+          "stakeholders": ["creator", "consumer"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-06",
+      "dimension": "lifecycle",
+      "trigger": "description provided as the empty string",
+      "cases": [
+        {
+          "when": { "field": "description_empty", "op": "eq", "value": true },
+          "level": "low",
+          "title": "description missing — Proof hard to identify in queries and audit logs",
+          "description": "description is a REQUIRED field (PF-D-2=A). The Move contract stores it as a String field and SDK passes it to the proof-creation call. An empty description (\"\") is technically valid but makes the Proof hard to identify in query results and audit logs. Non-empty descriptions are strongly recommended.",
+          "scenario": "Caller passes description=\"\" to save typing",
+          "mitigation": "Provide a one-line description like \"KYC attestation for user 0xabc\" or \"merkle root for batch #42\".",
+          "evidence": "description=\"\" (empty)",
+          "stakeholders": ["creator", "verifier"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-08",
+      "dimension": "knowledge",
+      "trigger": "proof constants not synced to the knowledge constant table",
+      "cases": [
+        {
+          "when": { "field": "constants_synced", "op": "falsy" },
+          "level": "info",
+          "title": "Knowledge layer & constant sync — RESOLVED",
+          "description": "All 4 Proof constants (WOWOK_WTS_PROOF_TYPE, MAX_PROOF_SIZE, MAX_SERVER_PUBKEY_SIZE, MAX_SERVER_SIGNATURE_SIZE) are now synced to onchain-constants.ts (P-PROOF-P2-5). The MCP Knowledge layer now includes proof-risk.ts, proof-confirm.ts, proof-translation.ts (P-PROOF-P2-6). This risk rule is retained for historical audit and to detect future regressions.",
+          "scenario": "Future regression: someone removes a Proof constant from onchain-constants.ts",
+          "mitigation": "Run the onchain-constants sync test to detect drift.",
+          "evidence": "constants_synced=false",
+          "stakeholders": ["system"]
+        }
+      ]
+    },
+    {
+      "rule_id": "R-PROOF-07",
+      "dimension": "lifecycle",
+      "trigger": "unconditional — fires for every evaluation (appended last by the retired check)",
+      "cases": [
+        {
+          "when": { "field": "always_true", "op": "eq", "value": true },
+          "level": "high",
+          "title": "Proof is immutable — cannot modify after creation (freeze_object)",
+          "description": "Proof is created via transfer::freeze_object(obj) in Move. Once frozen, the object cannot be modified, transferred, or deleted. All fields (proof, server_pubkey, server_signature, about, proof_type, signer, time, description, item_count) are permanently fixed at the value set during creation. To 'update' a Proof, create a new one and update references.",
+          "scenario": "Caller wants to update server_signature after key rotation — cannot, must create new Proof",
+          "mitigation": "Verify all fields before creating the Proof. For scenarios requiring key rotation, create a new Proof and update the referencing object (Repository data, Service config, etc.) to point to the new Proof address.",
+          "stakeholders": ["creator", "consumer"]
+        }
+      ]
+    }
+  ]
+}