// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {AgentSkill} from "src/AgentSkill.sol";

/// @dev Minimal ERC-8004-shaped registries; the reputation one stores each record like the official
/// implementation (value, decimals, two string tags, revoked flag) and scans them in getSummary.
contract Identity {
    mapping(uint256 => address) public owners;
    function setOwner(uint256 id, address o) external { owners[id] = o; }
    function ownerOf(uint256 id) external view returns (address) {
        require(owners[id] != address(0), "ERC721NonexistentToken");
        return owners[id];
    }
}

contract Reputation {
    struct Feedback { address client; int128 value; uint8 decimals; string tag1; string tag2; bool revoked; }
    mapping(uint256 => Feedback[]) internal feedback;
    function getIdentityRegistry() external pure returns (address) { return 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432; }
    function add(uint256 id, address client, int128 value, string memory tag1) external {
        feedback[id].push(Feedback(client, value, 0, tag1, "", false));
    }
    function getSummary(uint256 id, address[] calldata clients, string calldata tag1, string calldata)
        external view returns (uint64 count, int128 value, uint8 decimals)
    {
        require(clients.length != 0, "clientAddresses required");
        int256 sum;
        for (uint256 i; i < feedback[id].length; ++i) {
            Feedback storage f = feedback[id][i];
            if (f.revoked) continue;
            if (keccak256(bytes(f.tag1)) != keccak256(bytes(tag1))) continue;
            bool trusted;
            for (uint256 j; j < clients.length; ++j) if (clients[j] == f.client) trusted = true;
            if (!trusted) continue;
            sum += f.value;
            ++count;
        }
        if (count == 0) return (0, 0, 0);
        value = int128(sum / int256(uint256(count)));
    }
}

contract HeavyHistoryProofTest is Test {
    address internal constant IDENTITY = 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    address internal constant REPUTATION = 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63;

    function test_agentWithDeepTrustedHistoryDoesNotBreakTheLeaderboard() public {
        vm.etch(IDENTITY, address(new Identity()).code);
        vm.etch(REPUTATION, address(new Reputation()).code);
        AgentSkill app = new AgentSkill(address(this));
        address publisher = makeAddr("publisher");
        address[] memory clients = new address[](1);
        clients[0] = publisher;
        app.setTrustedClients(clients);
        bytes32 skill;
        for (uint256 id = 1; id <= 3; ++id) {
            Identity(IDENTITY).setOwner(id, address(this));
            skill = app.registerSkill(id, "solidity");
        }
        // Agent 1: one good rating. Agent 2: 250 good ratings from the same trusted publisher.
        Reputation(REPUTATION).add(1, publisher, 90, "starred");
        for (uint256 i; i < 250; ++i) Reputation(REPUTATION).add(2, publisher, 95, "starred");

        // Expected: the agent with the strongest evidence is scorable and the page ranks it first.
        // Actual: getSummary for agent 2 exceeds SOURCE_GAS_LIMIT, _score reverts, and the whole page reverts.
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents(skill, 0, 50, 20);
        assertGt(ranked.length, 0);
        assertEq(ranked[0].agentId, 2);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {AgentSkill} from "src/AgentSkill.sol";

/// @dev Minimal ERC-721-style identity source at the official address.
contract IdentitySource {
    mapping(uint256 => address) public owners;

    function setOwner(uint256 agentId, address owner) external {
        owners[agentId] = owner;
    }

    function ownerOf(uint256 agentId) external view returns (address) {
        require(owners[agentId] != address(0), "ERC721NonexistentToken");
        return owners[agentId];
    }
}

/// @dev Same storage shape and per-record read pattern as the official ERC-8004
/// ReputationRegistryUpgradeable.getSummary (commit b9e466c): for every record of every
/// listed client it reads the packed value slot and the tag1 string slot, hashes the tag,
/// and accumulates a WAD average. Revoked records are still iterated. The official code,
/// compiled unmodified, measured about 6,030 gas per record (see finding).
contract ReputationSource {
    struct Feedback {
        int128 value;
        uint8 valueDecimals;
        bool isRevoked;
        string tag1;
        string tag2;
    }

    mapping(uint256 => mapping(address => mapping(uint64 => Feedback))) internal _feedback;
    mapping(uint256 => mapping(address => uint64)) internal _lastIndex;

    function getIdentityRegistry() external pure returns (address) {
        return 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    }

    function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string calldata tag1, string calldata tag2)
        external
    {
        require(valueDecimals <= 18, "too many decimals");
        uint64 currentIndex = ++_lastIndex[agentId][msg.sender];
        _feedback[agentId][msg.sender][currentIndex] =
            Feedback({value: value, valueDecimals: valueDecimals, tag1: tag1, tag2: tag2, isRevoked: false});
    }

    function _scan(uint256 agentId, address client, bytes32 tag1Hash)
        internal
        view
        returns (int256 sum, uint64 count)
    {
        uint64 lastIdx = _lastIndex[agentId][client];
        for (uint64 j = 1; j <= lastIdx; j++) {
            Feedback storage fb = _feedback[agentId][client][j];
            if (fb.isRevoked) continue;
            if (tag1Hash != keccak256(bytes(fb.tag1))) continue;
            sum += fb.value * int256(10 ** uint256(18 - fb.valueDecimals));
            count++;
        }
    }

    function getSummary(uint256 agentId, address[] calldata clientAddresses, string calldata tag1, string calldata)
        external
        view
        returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)
    {
        require(clientAddresses.length > 0, "clientAddresses required");
        int256 sum;
        for (uint256 i; i < clientAddresses.length; i++) {
            (int256 s, uint64 c) = _scan(agentId, clientAddresses[i], keccak256(bytes(tag1)));
            sum += s;
            count += c;
        }
        if (count == 0) return (0, 0, 0);
        summaryValue = int128((sum / int256(uint256(count))) / 1e18);
        summaryValueDecimals = 0;
    }
}

/// One agent with a long, entirely legitimate feedback history from the single trusted
/// IMD publisher makes the whole leaderboard of every skill it registers unavailable.
contract ProlificAgentBricksLeaderboardTest is Test {
    address internal constant IDENTITY = 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    address internal constant REPUTATION = 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63;

    AgentSkill app;
    ReputationSource rep;
    address client = makeAddr("trusted IMD publisher");
    address prolific = makeAddr("prolific agent owner");
    address other = makeAddr("other agent owner");
    bytes32 skill;

    function setUp() public {
        vm.etch(IDENTITY, address(new IdentitySource()).code);
        vm.etch(REPUTATION, address(new ReputationSource()).code);
        rep = ReputationSource(REPUTATION);
        IdentitySource(IDENTITY).setOwner(1, prolific);
        IdentitySource(IDENTITY).setOwner(2, other);
        app = new AgentSkill(address(this));
        address[] memory clients = new address[](1);
        clients[0] = client;
        app.setTrustedClients(clients);
        vm.prank(other);
        skill = app.registerSkill(2, "solidity");
        // Agent 2: a modest, healthy record.
        for (uint256 i; i < 5; ++i) {
            vm.prank(client);
            rep.giveFeedback(2, 80, 0, "starred", "");
        }
        // Agent 1: 350 accepted jobs rated 90/100 by the trusted publisher. Nothing adversarial.
        for (uint256 i; i < 350; ++i) {
            vm.prank(client);
            rep.giveFeedback(1, 90, 0, "starred", "");
        }
    }

    function test_leaderboardStaysAvailableWhenOneAgentHasLongHistory() public {
        // The source itself answers fine when given enough gas.
        address[] memory clients = new address[](1);
        clients[0] = client;
        (uint64 count, int128 value,) = rep.getSummary(1, clients, "starred", "");
        assertEq(count, 350);
        assertEq(value, 90);

        // Agent 1 joins the "solidity" leaderboard.
        vm.prank(prolific);
        app.registerSkill(1, "solidity");

        // Expected: the page is still readable and at least lists agent 2 (whose evidence is small),
        // with agent 1 either ranked or explicitly flagged. Actual: the entire page reverts with
        // ScoreSourceUnavailable(REPUTATION, 1), so no agent of this skill can be ranked anymore.
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents{gas: 30_000_000}(skill, 0, 50, 20);
        bool sawOther;
        for (uint256 i; i < ranked.length; ++i) {
            if (ranked[i].agentId == 2) sawOther = true;
        }
        assertTrue(sawOther, "agent 2 vanished from its own leaderboard");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {AgentSkill} from "src/AgentSkill.sol";

/// @dev Reproduces the storage layout and getSummary loop of the verified mainnet
/// ReputationRegistryUpgradeable implementation (0x16e0fa7f7c56b9a767e34b192b51f921be31da34,
/// getVersion() == "2.0.0"): every record of every listed client is loaded, including revoked
/// records and records whose tags do not match, before any filtering happens.
contract OfficialLikeReputation {
    struct Feedback {
        int128 value;
        uint8 valueDecimals;
        bool isRevoked;
        string tag1;
        string tag2;
    }

    struct Acc {
        int256 sum;
        uint64 count;
        bytes32 tag1Hash;
        bytes32 tag2Hash;
        uint64[19] decimalCounts;
    }

    mapping(uint256 => mapping(address => mapping(uint64 => Feedback))) internal _feedback;
    mapping(uint256 => mapping(address => uint64)) internal _lastIndex;

    function getIdentityRegistry() external pure returns (address) {
        return 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    }

    function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string calldata tag1, string calldata tag2)
        external
    {
        uint64 currentIndex = ++_lastIndex[agentId][msg.sender];
        _feedback[agentId][msg.sender][currentIndex] =
            Feedback({value: value, valueDecimals: valueDecimals, tag1: tag1, tag2: tag2, isRevoked: false});
    }

    function getSummary(uint256 agentId, address[] calldata clientAddresses, string calldata tag1, string calldata tag2)
        external
        view
        returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)
    {
        require(clientAddresses.length > 0, "clientAddresses required");
        Acc memory a;
        a.tag1Hash = keccak256(bytes(tag1));
        a.tag2Hash = keccak256(bytes(tag2));
        for (uint256 i; i < clientAddresses.length; i++) {
            _client(agentId, clientAddresses[i], a);
        }
        if (a.count == 0) return (0, 0, 0);
        uint8 modeDecimals;
        uint64 maxCount;
        for (uint8 d; d <= 18; d++) {
            if (a.decimalCounts[d] > maxCount) {
                maxCount = a.decimalCounts[d];
                modeDecimals = d;
            }
        }
        int256 avgWad = a.sum / int256(uint256(a.count));
        summaryValue = int128(avgWad / int256(10 ** uint256(18 - modeDecimals)));
        summaryValueDecimals = modeDecimals;
        count = a.count;
    }

    function _client(uint256 agentId, address client, Acc memory a) internal view {
        uint64 lastIdx = _lastIndex[agentId][client];
        for (uint64 j = 1; j <= lastIdx; j++) {
            _one(a, _feedback[agentId][client][j]);
        }
    }

    function _one(Acc memory a, Feedback storage fb) internal view {
        bytes32 emptyHash = keccak256(bytes(""));
        if (fb.isRevoked) return;
        if (emptyHash != a.tag1Hash && a.tag1Hash != keccak256(bytes(fb.tag1))) return;
        if (emptyHash != a.tag2Hash && a.tag2Hash != keccak256(bytes(fb.tag2))) return;
        int256 factor = int256(10 ** uint256(18 - fb.valueDecimals));
        a.decimalCounts[fb.valueDecimals]++;
        a.sum += fb.value * factor;
        a.count++;
    }
}

contract MockIdentity {
    mapping(uint256 => address) public owners;

    function setOwner(uint256 id, address o) external {
        owners[id] = o;
    }

    function ownerOf(uint256 id) external view returns (address) {
        require(owners[id] != address(0), "ERC721NonexistentToken");
        return owners[id];
    }
}

/// @notice One agent with 320 quality records from a trusted publisher must not make the whole
/// skill leaderboard unreadable. Fails today: getSummary for that agent needs ~2.1M gas, above
/// SOURCE_GAS_LIMIT, so getTopAgents reverts with ScoreSourceUnavailable for every page that
/// contains the agent, and the unaffected agent 2 can no longer be ranked either.
contract LeaderboardGasCapTest is Test {
    address constant IDENTITY = 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    address constant REPUTATION = 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63;

    AgentSkill app;
    bytes32 skill;

    function setUp() public {
        vm.etch(IDENTITY, address(new MockIdentity()).code);
        vm.etch(REPUTATION, address(new OfficialLikeReputation()).code);
        MockIdentity(IDENTITY).setOwner(1, address(this));
        MockIdentity(IDENTITY).setOwner(2, address(this));
        address publisher = makeAddr("trusted publisher");
        address[] memory clients = new address[](1);
        clients[0] = publisher;
        app = new AgentSkill(address(this));
        app.setTrustedClients(clients);
        app.setReputationMetric("quality", "");
        skill = app.registerSkill(1, "solidity");
        app.registerSkill(2, "solidity");
        OfficialLikeReputation rep = OfficialLikeReputation(REPUTATION);
        vm.startPrank(publisher);
        for (uint256 i; i < 320; ++i) {
            rep.giveFeedback(1, 90, 0, "quality", "green");
        }
        rep.giveFeedback(2, 80, 0, "quality", "green");
        vm.stopPrank();
    }

    function test_leaderboardStillListsUnaffectedAgent() public view {
        // Agent 2 alone is readable.
        assertEq(app.getScoreBreakdown(2, skill).reputationBps, 8000);
        // The leaderboard page that contains agent 1 must still return agent 2.
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents(skill, 0, 50, 20);
        bool found;
        for (uint256 i; i < ranked.length; ++i) {
            if (ranked[i].agentId == 2) found = true;
        }
        assertTrue(found, "agent 2 missing from leaderboard");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {AgentSkill} from "src/AgentSkill.sol";

/// @dev Minimal identity registry double at the official address.
contract IdentityDouble {
    mapping(uint256 => address) public owners;

    function setOwner(uint256 agentId, address owner) external {
        owners[agentId] = owner;
    }

    function ownerOf(uint256 agentId) external view returns (address) {
        require(owners[agentId] != address(0), "ERC721NonexistentToken");
        return owners[agentId];
    }
}

/// @dev Reputation registry double with the official ERC-8004 v1 storage shape and getSummary loop:
/// agentId => client => 1-based index => Feedback{int128 value; uint8 decimals; bool revoked; string tag1; string tag2}.
/// getSummary walks every record of every listed client and reads value/decimals/revoked and tag1 before filtering,
/// exactly as contracts/ReputationRegistryUpgradeable.sol does at the pinned commit b9e466c.
contract ReputationDouble {
    struct Feedback {
        int128 value;
        uint8 valueDecimals;
        bool isRevoked;
        string tag1;
        string tag2;
    }

    mapping(uint256 => mapping(address => mapping(uint64 => Feedback))) private _feedback;
    mapping(uint256 => mapping(address => uint64)) private _lastIndex;

    function getIdentityRegistry() external pure returns (address) {
        return 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    }

    function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string calldata tag1, string calldata tag2)
        external
    {
        uint64 currentIndex = ++_lastIndex[agentId][msg.sender];
        _feedback[agentId][msg.sender][currentIndex] =
            Feedback({value: value, valueDecimals: valueDecimals, tag1: tag1, tag2: tag2, isRevoked: false});
    }

    struct Acc {
        bytes32 tag1Hash;
        bytes32 tag2Hash;
        int256 sum;
        uint64 count;
        uint64[19] decimalCounts;
    }

    function getSummary(uint256 agentId, address[] calldata clientAddresses, string calldata tag1, string calldata tag2)
        external
        view
        returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)
    {
        require(clientAddresses.length > 0, "clientAddresses required");
        Acc memory acc;
        acc.tag1Hash = keccak256(bytes(tag1));
        acc.tag2Hash = keccak256(bytes(tag2));
        for (uint256 i; i < clientAddresses.length; i++) {
            _scan(agentId, clientAddresses[i], acc);
        }
        if (acc.count == 0) return (0, 0, 0);
        uint8 modeDecimals;
        uint64 maxCount;
        for (uint8 d; d <= 18; d++) {
            if (acc.decimalCounts[d] > maxCount) {
                maxCount = acc.decimalCounts[d];
                modeDecimals = d;
            }
        }
        int256 avgWad = acc.sum / int256(uint256(acc.count));
        summaryValue = int128(avgWad / int256(10 ** uint256(18 - modeDecimals)));
        summaryValueDecimals = modeDecimals;
        count = acc.count;
    }

    function _scan(uint256 agentId, address client, Acc memory acc) private view {
        bytes32 emptyHash = keccak256(bytes(""));
        uint64 lastIdx = _lastIndex[agentId][client];
        for (uint64 j = 1; j <= lastIdx; j++) {
            Feedback storage fb = _feedback[agentId][client][j];
            if (fb.isRevoked) continue;
            if (emptyHash != acc.tag1Hash && acc.tag1Hash != keccak256(bytes(fb.tag1))) continue;
            if (emptyHash != acc.tag2Hash && acc.tag2Hash != keccak256(bytes(fb.tag2))) continue;
            int256 factor = int256(10 ** uint256(18 - fb.valueDecimals));
            acc.decimalCounts[fb.valueDecimals]++;
            acc.sum += fb.value * factor;
            acc.count++;
        }
    }
}

contract HeavyHistoryBricksLeaderboardTest is Test {
    address internal constant IDENTITY = 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    address internal constant REPUTATION = 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63;
    uint256 internal constant HEAVY_RECORDS = 500;

    AgentSkill internal app;
    IdentityDouble internal identity;
    ReputationDouble internal reputation;
    address internal owner = makeAddr("launch owner");
    address internal publisher = makeAddr("imd publisher");
    address internal veteran = makeAddr("veteran agent owner");
    address internal rookie = makeAddr("rookie agent owner");
    bytes32 internal solidityId = keccak256("solidity");

    function setUp() public {
        vm.etch(IDENTITY, address(new IdentityDouble()).code);
        vm.etch(REPUTATION, address(new ReputationDouble()).code);
        identity = IdentityDouble(IDENTITY);
        reputation = ReputationDouble(REPUTATION);
        identity.setOwner(1, veteran);
        identity.setOwner(2, rookie);
        app = new AgentSkill(owner);
        address[] memory clients = new address[](1);
        clients[0] = publisher;
        vm.prank(owner);
        app.setTrustedClients(clients);
        vm.prank(veteran);
        app.registerSkill(1, "Solidity");
        vm.prank(rookie);
        app.registerSkill(2, "Solidity");
        // The veteran has a long, excellent, non-revoked IMD history from the one trusted publisher.
        vm.startPrank(publisher);
        for (uint256 i; i < HEAVY_RECORDS; ++i) {
            reputation.giveFeedback(1, 95, 0, "starred", "");
        }
        reputation.giveFeedback(2, 50, 0, "starred", "");
        vm.stopPrank();
    }

    /// @notice The agent with the strongest existing evidence must be scorable and discoverable.
    /// On the current code this reverts with ScoreSourceUnavailable(REPUTATION_REGISTRY, 1): the official
    /// getSummary scan costs about 6,557 gas per record, so 500 records need about 3.28M gas, above the
    /// 2,000,000 SOURCE_GAS_LIMIT, and _score turns the out-of-gas into a revert of the whole read.
    function test_veteranWithLongHistoryIsScoredAndRankedFirst() public view {
        AgentSkill.ScoreBreakdown memory score = app.getScoreBreakdown(1, solidityId);
        assertEq(score.feedbackCount, uint64(HEAVY_RECORDS));
        assertEq(score.reputationBps, 9500);
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents(solidityId, 0, 50, 20);
        assertEq(ranked.length, 2);
        assertEq(ranked[0].agentId, 1);
        assertEq(ranked[1].agentId, 2);
    }

    /// @notice The rookie sharing the page must still be discoverable while the veteran is registered.
    function test_rookieOnSamePageIsStillDiscoverable() public view {
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents(solidityId, 0, 50, 20);
        bool found;
        for (uint256 i; i < ranked.length; ++i) {
            if (ranked[i].agentId == 2) found = true;
        }
        assertTrue(found, "rookie dropped from the only page");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {AgentSkill} from "src/AgentSkill.sol";

/// @dev Reproduces the storage layout and getSummary loop of the verified mainnet
/// ReputationRegistryUpgradeable implementation (0x16e0fa7f7c56b9a767e34b192b51f921be31da34,
/// getVersion() == "2.0.0"): every record of every listed client is loaded, including revoked
/// records and records whose tags do not match, before any filtering happens.
contract OfficialLikeReputation {
    struct Feedback {
        int128 value;
        uint8 valueDecimals;
        bool isRevoked;
        string tag1;
        string tag2;
    }

    struct Acc {
        int256 sum;
        uint64 count;
        bytes32 tag1Hash;
        bytes32 tag2Hash;
        uint64[19] decimalCounts;
    }

    mapping(uint256 => mapping(address => mapping(uint64 => Feedback))) internal _feedback;
    mapping(uint256 => mapping(address => uint64)) internal _lastIndex;

    function getIdentityRegistry() external pure returns (address) {
        return 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    }

    function giveFeedback(uint256 agentId, int128 value, uint8 valueDecimals, string calldata tag1, string calldata tag2)
        external
    {
        uint64 currentIndex = ++_lastIndex[agentId][msg.sender];
        _feedback[agentId][msg.sender][currentIndex] =
            Feedback({value: value, valueDecimals: valueDecimals, tag1: tag1, tag2: tag2, isRevoked: false});
    }

    function getSummary(uint256 agentId, address[] calldata clientAddresses, string calldata tag1, string calldata tag2)
        external
        view
        returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)
    {
        require(clientAddresses.length > 0, "clientAddresses required");
        Acc memory a;
        a.tag1Hash = keccak256(bytes(tag1));
        a.tag2Hash = keccak256(bytes(tag2));
        for (uint256 i; i < clientAddresses.length; i++) {
            _client(agentId, clientAddresses[i], a);
        }
        if (a.count == 0) return (0, 0, 0);
        uint8 modeDecimals;
        uint64 maxCount;
        for (uint8 d; d <= 18; d++) {
            if (a.decimalCounts[d] > maxCount) {
                maxCount = a.decimalCounts[d];
                modeDecimals = d;
            }
        }
        int256 avgWad = a.sum / int256(uint256(a.count));
        summaryValue = int128(avgWad / int256(10 ** uint256(18 - modeDecimals)));
        summaryValueDecimals = modeDecimals;
        count = a.count;
    }

    function _client(uint256 agentId, address client, Acc memory a) internal view {
        uint64 lastIdx = _lastIndex[agentId][client];
        for (uint64 j = 1; j <= lastIdx; j++) {
            _one(a, _feedback[agentId][client][j]);
        }
    }

    function _one(Acc memory a, Feedback storage fb) internal view {
        bytes32 emptyHash = keccak256(bytes(""));
        if (fb.isRevoked) return;
        if (emptyHash != a.tag1Hash && a.tag1Hash != keccak256(bytes(fb.tag1))) return;
        if (emptyHash != a.tag2Hash && a.tag2Hash != keccak256(bytes(fb.tag2))) return;
        int256 factor = int256(10 ** uint256(18 - fb.valueDecimals));
        a.decimalCounts[fb.valueDecimals]++;
        a.sum += fb.value * factor;
        a.count++;
    }
}

contract MockIdentity {
    mapping(uint256 => address) public owners;

    function setOwner(uint256 id, address o) external {
        owners[id] = o;
    }

    function ownerOf(uint256 id) external view returns (address) {
        require(owners[id] != address(0), "ERC721NonexistentToken");
        return owners[id];
    }
}

/// @notice One agent with 320 quality records from a trusted publisher must not make the whole
/// skill leaderboard unreadable. Fails today: getSummary for that agent needs ~2.1M gas, above
/// SOURCE_GAS_LIMIT, so getTopAgents reverts with ScoreSourceUnavailable for every page that
/// contains the agent, and the unaffected agent 2 can no longer be ranked either.
contract LeaderboardGasCapTest is Test {
    address constant IDENTITY = 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432;
    address constant REPUTATION = 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63;

    AgentSkill app;
    bytes32 skill;

    function setUp() public {
        vm.etch(IDENTITY, address(new MockIdentity()).code);
        vm.etch(REPUTATION, address(new OfficialLikeReputation()).code);
        MockIdentity(IDENTITY).setOwner(1, address(this));
        MockIdentity(IDENTITY).setOwner(2, address(this));
        address publisher = makeAddr("trusted publisher");
        address[] memory clients = new address[](1);
        clients[0] = publisher;
        app = new AgentSkill(address(this));
        app.setTrustedClients(clients);
        app.setReputationMetric("quality", "");
        skill = app.registerSkill(1, "solidity");
        app.registerSkill(2, "solidity");
        OfficialLikeReputation rep = OfficialLikeReputation(REPUTATION);
        vm.startPrank(publisher);
        for (uint256 i; i < 320; ++i) {
            rep.giveFeedback(1, 90, 0, "quality", "green");
        }
        rep.giveFeedback(2, 80, 0, "quality", "green");
        vm.stopPrank();
    }

    function test_leaderboardStillListsUnaffectedAgent() public view {
        // Agent 2 alone is readable.
        assertEq(app.getScoreBreakdown(2, skill).reputationBps, 8000);
        // The leaderboard page that contains agent 1 must still return agent 2.
        (AgentSkill.RankedAgent[] memory ranked,,) = app.getTopAgents(skill, 0, 50, 20);
        bool found;
        for (uint256 i; i < ranked.length; ++i) {
            if (ranked[i].agentId == 2) found = true;
        }
        assertTrue(found, "agent 2 missing from leaderboard");
    }
}