Add warrantability scoring to registry

Author: FlowmemoryAI

README.md

@@ -91,6 +91,8 @@ Discovery for warranted agents.
 
 The registry does not rank generic vibes or profile copy. It checks whether an agent can actually support the required evidence and bond amount.
 
+It also emits a local `warrantabilityScore`: evidence fit plus bond capacity for this specific request.
+
 ### AgentRuntime
 
 The deterministic state machine for a warranted action:

docs/AGENT_FRAMEWORK_ARCHITECTURE.md

@@ -103,6 +103,8 @@ It matches by:
 - requested bond amount;
 - promise type.
 
+It also computes a local `warrantabilityScore` from evidence fit and bond capacity.
+
 This is not a reputation marketplace. It is a warranty-eligibility filter.
 
 ## Layer 6: AgentRuntime

docs/AGENT_REGISTRY.md

@@ -18,6 +18,13 @@ The registry checks:
 
 If an agent cannot provide the evidence path or cannot support the requested bond, it is rejected before the user treats the agent as warrantable.
 
+The local registry also emits a `warrantabilityScore`.
+
+That score is not reputation. It is a deterministic fit score for this request:
+
+- evidence support;
+- bond capacity.
+
 ## Why This Matters
 
 Agent marketplaces can make every agent look available.
@@ -42,9 +49,9 @@ Expected shape:
 FlowMemory Warranted Agent Registry
 
 Matches:
-  FlowMemory Warranted Research Agent ELIGIBLE
+  FlowMemory Warranted Research Agent ELIGIBLE score=100
     reasons: eligible_for_warranted_quote
-  Cheap Claim Agent                 REJECTED
+  Cheap Claim Agent                 REJECTED score=29
     reasons: missing_required_evidence, bond_request_exceeds_manifest_limit
 ```
 

flowmemory_compiler/agent_registry.py

@@ -18,6 +18,7 @@ class AgentMatch:
     missing_evidence: tuple[str, ...]
     requested_bond_units: int
     max_bond_units: int
+    warrantability_score: int
     reasons: tuple[str, ...]
 
 
@@ -37,7 +38,7 @@ def list_agents(self) -> list[dict[str, Any]]:
 
     def match(self, request: WorkRequest) -> list[AgentMatch]:
         matches = [_match_manifest(manifest, request) for manifest in self._manifests.values()]
-        return sorted(matches, key=lambda item: (not item.eligible, item.display_name))
+        return sorted(matches, key=lambda item: (not item.eligible, -item.warrantability_score, item.display_name))
 
 
 def run_registry_demo() -> dict[str, Any]:
@@ -85,6 +86,7 @@ def match_to_public(match: AgentMatch) -> dict[str, Any]:
         "missingEvidence": list(match.missing_evidence),
         "requestedBondUnits": match.requested_bond_units,
         "maxBondUnits": match.max_bond_units,
+        "warrantabilityScore": match.warrantability_score,
         "reasons": list(match.reasons),
     }
 
@@ -104,6 +106,12 @@ def _match_manifest(manifest: AgentManifest, request: WorkRequest) -> AgentMatch
         reasons.append("unsupported_promise_type")
     if not reasons:
         reasons.append("eligible_for_warranted_quote")
+    score = _warrantability_score(
+        required_count=len(required),
+        matched_count=len(matched),
+        requested_bond_units=request.requested_bond_units,
+        max_bond_units=manifest.max_bond_units,
+    )
     return AgentMatch(
         agent_id=manifest.agent_id,
         display_name=manifest.display_name,
@@ -113,5 +121,24 @@ def _match_manifest(manifest: AgentManifest, request: WorkRequest) -> AgentMatch
         missing_evidence=missing,
         requested_bond_units=request.requested_bond_units,
         max_bond_units=manifest.max_bond_units,
+        warrantability_score=score,
         reasons=tuple(reasons),
     )
+
+
+def _warrantability_score(
+    *,
+    required_count: int,
+    matched_count: int,
+    requested_bond_units: int,
+    max_bond_units: int,
+) -> int:
+    if required_count == 0:
+        evidence_score = 70
+    else:
+        evidence_score = int(70 * (matched_count / required_count))
+    if requested_bond_units <= 0:
+        bond_score = 30
+    else:
+        bond_score = int(30 * min(max_bond_units / requested_bond_units, 1))
+    return min(100, evidence_score + bond_score)

flowmemory_compiler/cli.py

@@ -429,7 +429,7 @@ def _print_agent_registry(result: dict[str, Any]) -> None:
     print("Matches:")
     for match in result["matches"]:
         status = "ELIGIBLE" if match["eligible"] else "REJECTED"
-        print(f"  {match['displayName']:<32} {status}")
+        print(f"  {match['displayName']:<32} {status} score={match['warrantabilityScore']}")
         print(f"    reasons: {', '.join(match['reasons'])}")
         if match["missingEvidence"]:
             print(f"    missing: {', '.join(match['missingEvidence'])}")

tests/test_flowcompiler.py

@@ -229,8 +229,10 @@ def test_agent_registry_matches_warranted_agent(self):
         self.assertEqual(result["schema"], "flowmemory.agent_registry_demo.v0")
         self.assertEqual(len(result["matches"]), 2)
         self.assertTrue(result["matches"][0]["eligible"])
+        self.assertEqual(result["matches"][0]["warrantabilityScore"], 100)
         self.assertEqual(result["matches"][0]["reasons"], ["eligible_for_warranted_quote"])
         self.assertFalse(result["matches"][1]["eligible"])
+        self.assertLess(result["matches"][1]["warrantabilityScore"], 100)
         self.assertIn("missing_required_evidence", result["matches"][1]["reasons"])
 
     def test_agent_runtime_runs_success_and_failure_histories(self):