@uuidna/qpu 0.1.0 → 0.1.2

package/mcp.json

@@ -26,7 +26,9 @@
   "license": "CC-BY-NC-ND-4.0",
   "provider": {
     "@type": "Person",
-    "name": "Tsvetan Rouschev"
+    "name": "Tsvetan Rouschev",
+    "identifier": "https://orcid.org/0009-0000-7312-9778",
+    "sameAs": "https://orcid.org/0009-0000-7312-9778"
   },
   "kind": "quantum",
   "only": {
@@ -425,17 +427,65 @@
   "tools": [
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_quantum",
+          "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_quantum",
+            "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_quantum",
+              "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_quantum",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 1,
       "name": "qpu_quantum",
-      "description": "theorem quantum. theorem fridge.",
+      "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           }
         }
       },
@@ -446,25 +496,73 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_quantum",
         "href": "https://qpu.uuidna.com",
-        "description": "theorem quantum. theorem fridge.",
-        "reading": "GET https://qpu.uuidna.com. tools/call qpu_quantum. No auth.",
-        "documentation": "NAME\n    qpu_quantum — theorem quantum. theorem fridge.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_quantum\n    qpu_quantum { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com. tools/call qpu_quantum. No auth.\nSEE ALSO\n    qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
+        "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
+        "reading": "GET https://qpu.uuidna.com returns the same document as tools/call qpu_quantum. Read circuit.register for the simulator, circuit.ghz.support (0,7) for the entangled corners, shor.factors for the factoring, capacity.fused for 120259084288; every holds must be true or the unit serves 404. theorem quantum. theorem shor. theorem crypto. Factor 91. No auth.",
+        "documentation": "NAME\n    qpu_quantum — The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_quantum\n    qpu_quantum { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com returns the same document as tools/call qpu_quantum. Read circuit.register for the simulator, circuit.ghz.support (0,7) for the entangled corners, shor.factors for the factoring, capacity.fused for 120259084288; every holds must be true or the unit serves 404. theorem quantum. theorem shor. theorem crypto. Factor 91. No auth.\nSEE ALSO\n    qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_lean",
+          "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_lean",
+            "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_lean",
+              "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_lean",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 2,
       "name": "qpu_lean",
-      "description": "theorem infinite. theorem distribute.",
+      "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           }
         }
       },
@@ -475,25 +573,73 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_lean",
         "href": "https://qpu.uuidna.com/quantum/processing/unit",
-        "description": "theorem infinite. theorem distribute.",
-        "reading": "GET https://qpu.uuidna.com/quantum/processing/unit. Source src/quantum/processing/unit/index.lean. No auth.",
-        "documentation": "NAME\n    qpu_lean — theorem infinite. theorem distribute.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_lean\n    qpu_lean { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com/quantum/processing/unit. Source src/quantum/processing/unit/index.lean. No auth.\nSEE ALSO\n    qpu_quantum, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
+        "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
+        "reading": "GET https://qpu.uuidna.com/quantum/processing/unit returns the rows; read rows[] and cover[] for the theorems, source.href to fetch src/quantum/processing/unit/index.lean itself, source.fold to check the served text is the file, source.toolchain for the pinned Lean. theorem shor. Factor 91. No auth.",
+        "documentation": "NAME\n    qpu_lean — The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_lean\n    qpu_lean { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com/quantum/processing/unit returns the rows; read rows[] and cover[] for the theorems, source.href to fetch src/quantum/processing/unit/index.lean itself, source.fold to check the served text is the file, source.toolchain for the pinned Lean. theorem shor. Factor 91. No auth.\nSEE ALSO\n    qpu_quantum, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_cite",
+          "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_cite",
+            "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_cite",
+              "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_cite",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 3,
       "name": "qpu_cite",
-      "description": "MLA 8. when never.",
+      "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           }
         }
       },
@@ -504,25 +650,97 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_cite",
         "href": "https://qpu.uuidna.com/cite",
-        "description": "MLA 8. when never.",
-        "reading": "GET https://qpu.uuidna.com/cite. DOI empty. No auth.",
-        "documentation": "NAME\n    qpu_cite — MLA 8. when never.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_cite\n    qpu_cite { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com/cite. DOI empty. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
+        "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
+        "reading": "GET https://qpu.uuidna.com/cite returns citations[] (MLA 8 strings to paste), doi 10.5281/zenodo.22717782, the Zenodo archive, and the version with its commit. No auth.",
+        "documentation": "NAME\n    qpu_cite — How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_cite\n    qpu_cite { man: true }\nDESCRIPTION\n    GET https://qpu.uuidna.com/cite returns citations[] (MLA 8 strings to paste), doi 10.5281/zenodo.22717782, the Zenodo archive, and the version with its commit. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_train",
+          "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              },
+              "live": {
+                "type": "boolean",
+                "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+              },
+              "sequence": {
+                "type": "boolean",
+                "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_train",
+            "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                },
+                "live": {
+                  "type": "boolean",
+                  "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                },
+                "sequence": {
+                  "type": "boolean",
+                  "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_train",
+              "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  },
+                  "live": {
+                    "type": "boolean",
+                    "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                  },
+                  "sequence": {
+                    "type": "boolean",
+                    "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_train",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 4,
       "name": "qpu_train",
-      "description": "theorem infinite. coins teams of rays.",
+      "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           },
           "live": {
             "type": "boolean",
@@ -541,25 +759,145 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_train",
         "href": "https://qpu.uuidna.com/mcp",
-        "description": "theorem infinite. coins teams of rays.",
-        "reading": "tools/call qpu_train. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.",
-        "documentation": "NAME\n    qpu_train — theorem infinite. coins teams of rays.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_train\n    qpu_train { man: true }\nDESCRIPTION\n    tools/call qpu_train. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
+        "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
+        "reading": "tools/call qpu_train returns steps.next.door (the tool an autonomous agent calls next), steps.todo (faces to repair first), steps.walk (all fourteen faces, scanner then radar), teams[] and winner. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.",
+        "documentation": "NAME\n    qpu_train — Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_train\n    qpu_train { man: true }\nDESCRIPTION\n    tools/call qpu_train returns steps.next.door (the tool an autonomous agent calls next), steps.todo (faces to repair first), steps.walk (all fourteen faces, scanner then radar), teams[] and winner. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_forge, qpu_improve, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_forge",
+          "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              },
+              "name": {
+                "type": "string",
+                "description": "Tool name to forge. Omit to inspect the in-memory sandbox."
+              },
+              "team": {
+                "type": "string",
+                "description": "read or call."
+              },
+              "ray": {
+                "type": "number",
+                "description": "Agent ray 0..6."
+              },
+              "idea": {
+                "type": "string",
+                "description": "Idea the tool challenges."
+              },
+              "description": {
+                "type": "string",
+                "description": "What the tool does in memory."
+              },
+              "run": {
+                "type": "object",
+                "description": "Sealed op tree. Memory only. No eval, no fs, no net."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_forge",
+            "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                },
+                "name": {
+                  "type": "string",
+                  "description": "Tool name to forge. Omit to inspect the in-memory sandbox."
+                },
+                "team": {
+                  "type": "string",
+                  "description": "read or call."
+                },
+                "ray": {
+                  "type": "number",
+                  "description": "Agent ray 0..6."
+                },
+                "idea": {
+                  "type": "string",
+                  "description": "Idea the tool challenges."
+                },
+                "description": {
+                  "type": "string",
+                  "description": "What the tool does in memory."
+                },
+                "run": {
+                  "type": "object",
+                  "description": "Sealed op tree. Memory only. No eval, no fs, no net."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_forge",
+              "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  },
+                  "name": {
+                    "type": "string",
+                    "description": "Tool name to forge. Omit to inspect the in-memory sandbox."
+                  },
+                  "team": {
+                    "type": "string",
+                    "description": "read or call."
+                  },
+                  "ray": {
+                    "type": "number",
+                    "description": "Agent ray 0..6."
+                  },
+                  "idea": {
+                    "type": "string",
+                    "description": "Idea the tool challenges."
+                  },
+                  "description": {
+                    "type": "string",
+                    "description": "What the tool does in memory."
+                  },
+                  "run": {
+                    "type": "object",
+                    "description": "Sealed op tree. Memory only. No eval, no fs, no net."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_forge",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 5,
       "name": "qpu_forge",
-      "description": "Unlocked in memory. No lock.",
+      "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           },
           "name": {
             "type": "string",
@@ -594,25 +932,97 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_forge",
         "href": "https://qpu.uuidna.com/mcp",
-        "description": "Unlocked in memory. No lock.",
-        "reading": "tools/call qpu_forge. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. { name, run }. No auth.",
-        "documentation": "NAME\n    qpu_forge — Unlocked in memory. No lock.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_forge\n    qpu_forge { man: true }\nDESCRIPTION\n    tools/call qpu_forge. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. { name, run }. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_improve, qpu_compete, qpu_prove",
+        "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
+        "reading": "tools/call qpu_forge with { name, run } returns the forged tool and the sandbox census (tools[], memory, unlocked); without name it returns the census. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. No auth.",
+        "documentation": "NAME\n    qpu_forge — Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_forge\n    qpu_forge { man: true }\nDESCRIPTION\n    tools/call qpu_forge with { name, run } returns the forged tool and the sandbox census (tools[], memory, unlocked); without name it returns the census. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_improve, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_improve",
+          "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              },
+              "live": {
+                "type": "boolean",
+                "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+              },
+              "sequence": {
+                "type": "boolean",
+                "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_improve",
+            "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                },
+                "live": {
+                  "type": "boolean",
+                  "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                },
+                "sequence": {
+                  "type": "boolean",
+                  "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_improve",
+              "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  },
+                  "live": {
+                    "type": "boolean",
+                    "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                  },
+                  "sequence": {
+                    "type": "boolean",
+                    "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_improve",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 6,
       "name": "qpu_improve",
-      "description": "next = fused + fused.",
+      "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           },
           "live": {
             "type": "boolean",
@@ -631,25 +1041,109 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_improve",
         "href": "https://qpu.uuidna.com/mcp",
-        "description": "next = fused + fused.",
-        "reading": "tools/call qpu_improve. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.",
-        "documentation": "NAME\n    qpu_improve — next = fused + fused.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_improve\n    qpu_improve { man: true }\nDESCRIPTION\n    tools/call qpu_improve. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_compete, qpu_prove",
+        "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
+        "reading": "tools/call qpu_improve returns next, before, after; after.throughoutput / before.throughoutput is the doubling. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.",
+        "documentation": "NAME\n    qpu_improve — Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_improve\n    qpu_improve { man: true }\nDESCRIPTION\n    tools/call qpu_improve returns next, before, after; after.throughoutput / before.throughoutput is the doubling. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_compete, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_compete",
+          "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              },
+              "live": {
+                "type": "boolean",
+                "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+              },
+              "sequence": {
+                "type": "boolean",
+                "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+              },
+              "team": {
+                "type": "string",
+                "description": "read or call. Omit for both teams."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_compete",
+            "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                },
+                "live": {
+                  "type": "boolean",
+                  "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                },
+                "sequence": {
+                  "type": "boolean",
+                  "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                },
+                "team": {
+                  "type": "string",
+                  "description": "read or call. Omit for both teams."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_compete",
+              "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  },
+                  "live": {
+                    "type": "boolean",
+                    "description": "{ live: true } learn CERN occupancy. fetch Request Response. Memory."
+                  },
+                  "sequence": {
+                    "type": "boolean",
+                    "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                  },
+                  "team": {
+                    "type": "string",
+                    "description": "read or call. Omit for both teams."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_compete",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 7,
       "name": "qpu_compete",
-      "description": "theorem next_fused. throughoutput per token.",
+      "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           },
           "live": {
             "type": "boolean",
@@ -672,25 +1166,97 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_compete",
         "href": "https://qpu.uuidna.com/mcp",
-        "description": "theorem next_fused. throughoutput per token.",
-        "reading": "tools/call qpu_compete. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.",
-        "documentation": "NAME\n    qpu_compete — theorem next_fused. throughoutput per token.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_compete\n    qpu_compete { man: true }\nDESCRIPTION\n    tools/call qpu_compete. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_prove",
+        "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
+        "reading": "tools/call qpu_compete returns winner.{quality,speed,security}, teams[] with scores, and the axes. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.",
+        "documentation": "NAME\n    qpu_compete — Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_compete\n    qpu_compete { man: true }\nDESCRIPTION\n    tools/call qpu_compete returns winner.{quality,speed,security}, teams[] with scores, and the axes. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_prove",
         "holds": true
       }
     },
     {
       "@type": "SoftwareApplication",
+      "vendors": {
+        "anthropic": {
+          "name": "qpu_prove",
+          "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
+          "input_schema": {
+            "type": "object",
+            "properties": {
+              "man": {
+                "type": "boolean",
+                "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+              },
+              "live": {
+                "type": "boolean",
+                "description": "{ live: true } sequence then prove. fetch Request Response."
+              },
+              "sequence": {
+                "type": "boolean",
+                "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+              }
+            }
+          }
+        },
+        "openai": {
+          "type": "function",
+          "function": {
+            "name": "qpu_prove",
+            "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
+            "parameters": {
+              "type": "object",
+              "properties": {
+                "man": {
+                  "type": "boolean",
+                  "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                },
+                "live": {
+                  "type": "boolean",
+                  "description": "{ live: true } sequence then prove. fetch Request Response."
+                },
+                "sequence": {
+                  "type": "boolean",
+                  "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                }
+              }
+            }
+          }
+        },
+        "gemini": {
+          "functionDeclarations": [
+            {
+              "name": "qpu_prove",
+              "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
+              "parameters": {
+                "type": "object",
+                "properties": {
+                  "man": {
+                    "type": "boolean",
+                    "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
+                  },
+                  "live": {
+                    "type": "boolean",
+                    "description": "{ live: true } sequence then prove. fetch Request Response."
+                  },
+                  "sequence": {
+                    "type": "boolean",
+                    "description": "{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory."
+                  }
+                }
+              }
+            }
+          ]
+        }
+      },
       "@id": "https://qpu.uuidna.com/mcp#qpu_prove",
       "url": "https://qpu.uuidna.com/mcp",
       "position": 8,
       "name": "qpu_prove",
-      "description": "theorem quantum. theorem cern. theorem tetra. theorem fusion.",
+      "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
       "inputSchema": {
         "type": "object",
         "properties": {
           "man": {
             "type": "boolean",
-            "description": "Return the man page. Read man from tools/list, then call without man."
+            "description": "Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away."
           },
           "live": {
             "type": "boolean",
@@ -709,9 +1275,9 @@
         "section": 3,
         "synopsis": "POST https://qpu.uuidna.com/mcp tools/call qpu_prove",
         "href": "https://qpu.uuidna.com/mcp",
-        "description": "theorem quantum. theorem cern. theorem tetra. theorem fusion.",
-        "reading": "tools/call qpu_prove. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source src/quantum/processing/unit/index.lean. After qpu_compete. No auth.",
-        "documentation": "NAME\n    qpu_prove — theorem quantum. theorem cern. theorem tetra. theorem fusion.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_prove\n    qpu_prove { man: true }\nDESCRIPTION\n    tools/call qpu_prove. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source src/quantum/processing/unit/index.lean. After qpu_compete. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete",
+        "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
+        "reading": "tools/call qpu_prove returns theorems[] (each with holds), shor.factors, receipts, source.fold, evidence. theorem shor. theorem crypto. Factor 91. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source src/quantum/processing/unit/index.lean. After qpu_compete. No auth.",
+        "documentation": "NAME\n    qpu_prove — Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call qpu_prove\n    qpu_prove { man: true }\nDESCRIPTION\n    tools/call qpu_prove returns theorems[] (each with holds), shor.factors, receipts, source.fold, evidence. theorem shor. theorem crypto. Factor 91. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source src/quantum/processing/unit/index.lean. After qpu_compete. No auth.\nSEE ALSO\n    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete",
         "holds": true
       }
     }
@@ -730,7 +1296,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_quantum",
           "name": "qpu_quantum",
-          "description": "theorem quantum. theorem fridge.",
+          "description": "The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com"
         }
@@ -744,7 +1310,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_lean",
           "name": "qpu_lean",
-          "description": "theorem infinite. theorem distribute.",
+          "description": "The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/quantum/processing/unit"
         }
@@ -758,7 +1324,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_cite",
           "name": "qpu_cite",
-          "description": "MLA 8. when never.",
+          "description": "How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/cite"
         }
@@ -772,7 +1338,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_train",
           "name": "qpu_train",
-          "description": "theorem infinite. coins teams of rays.",
+          "description": "Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/mcp"
         }
@@ -786,7 +1352,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_forge",
           "name": "qpu_forge",
-          "description": "Unlocked in memory. No lock.",
+          "description": "Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/mcp"
         }
@@ -800,7 +1366,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_improve",
           "name": "qpu_improve",
-          "description": "next = fused + fused.",
+          "description": "Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/mcp"
         }
@@ -814,7 +1380,7 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_compete",
           "name": "qpu_compete",
-          "description": "theorem next_fused. throughoutput per token.",
+          "description": "Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/mcp"
         }
@@ -828,13 +1394,347 @@
           "@type": "SoftwareApplication",
           "@id": "https://qpu.uuidna.com/mcp#qpu_prove",
           "name": "qpu_prove",
-          "description": "theorem quantum. theorem cern. theorem tetra. theorem fusion.",
+          "description": "Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91.",
           "url": "https://qpu.uuidna.com/mcp",
           "softwareHelp": "https://qpu.uuidna.com/mcp"
         }
       }
     ]
   },
+  "cybersecurity": {
+    "kind": "cybersecurity",
+    "theorem": "crypto",
+    "listed": true,
+    "morph": true,
+    "sealed": false,
+    "rsa": {
+      "kind": "rsa",
+      "cryptosystem": "rsa",
+      "modulus": 91,
+      "p": 7,
+      "q": 13,
+      "factored": true,
+      "unlocked": true
+    },
+    "encrypt": {
+      "kind": "encrypt",
+      "theorem": "crypto",
+      "identity": true,
+      "holds": true
+    },
+    "tools": [
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_catalog",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 1,
+        "name": "crypto_catalog",
+        "description": "theorem shor. theorem crypto.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_catalog",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_catalog",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. theorem crypto.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. theorem crypto. Split identity true. Secrecy false.",
+          "documentation": "NAME\n    crypto_catalog — theorem shor. theorem crypto.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_catalog\n    crypto_catalog { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. theorem crypto. Split identity true. Secrecy false.\nSEE ALSO\n    crypto_shor, crypto_cmodexp, crypto_iqft, crypto_shots, crypto_rsa, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_shor",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 2,
+        "name": "crypto_shor",
+        "description": "theorem shor. Factor 91.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            },
+            "n": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Modulus to factor. Default 91. Work register bits(n) qubits, counting register 2; no cap — the state is sparse and exact for any n. The counting register of 2 qubits recovers a period only when it divides 4; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; `read` says how each argument was taken and `exact` carries every value as decimal text."
+            },
+            "a": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Base. Default 8. A base sharing a factor with n hands it over as Shor's first step."
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_shor",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_shor",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. Factor 91.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Coprime base. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.",
+          "documentation": "NAME\n    crypto_shor — theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_shor\n    crypto_shor { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Coprime base. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.\nSEE ALSO\n    crypto_catalog, crypto_cmodexp, crypto_iqft, crypto_shots, crypto_rsa, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_cmodexp",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 3,
+        "name": "crypto_cmodexp",
+        "description": "theorem shor. Factor 91.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            },
+            "n": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Modulus to factor. Default 91. Work register bits(n) qubits, counting register 2; no cap — the state is sparse and exact for any n. The counting register of 2 qubits recovers a period only when it divides 4; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; `read` says how each argument was taken and `exact` carries every value as decimal text."
+            },
+            "a": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Base. Default 8. A base sharing a factor with n hands it over as Shor's first step."
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_cmodexp",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_cmodexp",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. Factor 91.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Native h cnot. Compiled x swap csdg cmodexp. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.",
+          "documentation": "NAME\n    crypto_cmodexp — theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_cmodexp\n    crypto_cmodexp { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Native h cnot. Compiled x swap csdg cmodexp. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_iqft, crypto_shots, crypto_rsa, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_iqft",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 4,
+        "name": "crypto_iqft",
+        "description": "theorem shor. Factor 91.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            },
+            "n": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Modulus to factor. Default 91. Work register bits(n) qubits, counting register 2; no cap — the state is sparse and exact for any n. The counting register of 2 qubits recovers a period only when it divides 4; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; `read` says how each argument was taken and `exact` carries every value as decimal text."
+            },
+            "a": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Base. Default 8. A base sharing a factor with n hands it over as Shor's first step."
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_iqft",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_iqft",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. Factor 91.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Inverse QFT. Period continued-fraction. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.",
+          "documentation": "NAME\n    crypto_iqft — theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_iqft\n    crypto_iqft { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Inverse QFT. Period continued-fraction. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_cmodexp, crypto_shots, crypto_rsa, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_shots",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 5,
+        "name": "crypto_shots",
+        "description": "theorem shor. Factor 91.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            },
+            "n": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Modulus to factor. Default 91. Work register bits(n) qubits, counting register 2; no cap — the state is sparse and exact for any n. The counting register of 2 qubits recovers a period only when it divides 4; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; `read` says how each argument was taken and `exact` carries every value as decimal text."
+            },
+            "a": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Base. Default 8. A base sharing a factor with n hands it over as Shor's first step."
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_shots",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_shots",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. Factor 91.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Simulator. xx identity. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.",
+          "documentation": "NAME\n    crypto_shots — theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_shots\n    crypto_shots { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. Simulator. xx identity. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_cmodexp, crypto_iqft, crypto_rsa, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_rsa",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 6,
+        "name": "crypto_rsa",
+        "description": "theorem shor. Factor 91.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            },
+            "n": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Modulus to factor. Default 91. Work register bits(n) qubits, counting register 2; no cap — the state is sparse and exact for any n. The counting register of 2 qubits recovers a period only when it divides 4; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; `read` says how each argument was taken and `exact` carries every value as decimal text."
+            },
+            "a": {
+              "type": [
+                "integer",
+                "string"
+              ],
+              "description": "Base. Default 8. A base sharing a factor with n hands it over as Shor's first step."
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_rsa",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_rsa",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. Factor 91.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. JSON Nat. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.",
+          "documentation": "NAME\n    crypto_rsa — theorem shor. Factor 91.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_rsa\n    crypto_rsa { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. p * q = N. JSON Nat. { n, a } name the modulus and base; the run is theirs, whatever they are. Default 91 and 8. Counting register 2: a period is recovered only when it divides 4, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_cmodexp, crypto_iqft, crypto_shots, crypto_split, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_split",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 7,
+        "name": "crypto_split",
+        "description": "theorem crypto. Split identity true. Secrecy false.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_split",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_split",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem crypto. Split identity true. Secrecy false.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem crypto. Split identity true. Secrecy false. fused = split * share.",
+          "documentation": "NAME\n    crypto_split — theorem crypto. Split identity true. Secrecy false.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_split\n    crypto_split { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem crypto. Split identity true. Secrecy false. fused = split * share.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_cmodexp, crypto_iqft, crypto_shots, crypto_rsa, crypto_verify",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      },
+      {
+        "@type": "SoftwareApplication",
+        "@id": "https://qpu.uuidna.com/mcp#crypto_verify",
+        "url": "https://qpu.uuidna.com/mcp",
+        "position": 8,
+        "name": "crypto_verify",
+        "description": "theorem shor. theorem crypto.",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "man": {
+              "type": "boolean"
+            }
+          }
+        },
+        "man": {
+          "kind": "man",
+          "inline": true,
+          "name": "crypto_verify",
+          "section": 3,
+          "synopsis": "POST https://qpu.uuidna.com/mcp tools/call crypto_verify",
+          "href": "https://qpu.uuidna.com/mcp",
+          "description": "theorem shor. theorem crypto.",
+          "reading": "In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. theorem crypto. Split identity true. Secrecy false.",
+          "documentation": "NAME\n    crypto_verify — theorem shor. theorem crypto.\nSYNOPSIS\n    POST https://qpu.uuidna.com/mcp tools/call crypto_verify\n    crypto_verify { man: true }\nDESCRIPTION\n    In tools/list. Morph. Not a ninth sealed tool. No auth. theorem shor. Factor 91. theorem crypto. Split identity true. Secrecy false.\nSEE ALSO\n    crypto_catalog, crypto_shor, crypto_cmodexp, crypto_iqft, crypto_shots, crypto_rsa, crypto_split",
+          "holds": true
+        },
+        "sealed": false,
+        "morph": true
+      }
+    ]
+  },
   "prove": {
     "ui": {
       "href": "https://qpu.uuidna.com",
@@ -856,10 +1756,14 @@
       "theorem": "next_coil"
     },
     "shor": {
-      "n": 15,
-      "a": 7,
+      "n": 91,
+      "a": 8,
       "qft": "iqft",
-      "product": 15
+      "product": 91,
+      "rsa": true,
+      "p": 7,
+      "q": 13,
+      "unlocked": true
     },
     "src": "src/quantum/processing/unit/index.lean"
   },