@jinn-network/client 0.1.9 → 0.2.0

package/dist/discovery/http.js

@@ -1,5 +1,6 @@
 import { DiscoveryUnavailableError, TASK_POST_WINDOW_BLOCKS, bucketTaskPostCounts } from './types.js';
 import { manifestDigestForCid } from '../adapters/mech/digest.js';
+import { createHttpCorpusDiscovery, DiscoveryUnavailableError as CoreDiscoveryUnavailableError, } from '@jinn-network/core/corpus-read';
 // ── GraphQL query strings ─────────────────────────────────────────────────────
 /**
  * Claimable tasks query. Fetches task rows in pages; attempt counts are
@@ -221,35 +222,24 @@ query OperatorCountAttempts($taskIds: [String!]!, $chainId: Int!, $limit: Int!,
 }
 `;
 /**
- * Paginated read of verdictEnvelopeMeta rows for swe-rebench-v2 successes,
- * scoped to a single SolverNet via `solverNetManifestCid` so multi-SolverNet
- * operators with overlapping instance_id pools don't cross-tenant over-count
- * (#669 Finding 2).
- *
- * Ponder's auto-GraphQL does not expose GROUP BY / count aggregations, so
- * getInstanceSuccessCounts pages this query with the `after` cursor and
- * groups client-side. Capped at 1000 per page (Ponder's upper bound on
- * plural-query `limit`).
+ * Leg 1 of getInstanceClaimCounts (#802): page every task id + maxClaims for a
+ * SolverNet's manifestDigest. Leg 2 reuses ATTEMPTS_FOR_TASKS_QUERY to count
+ * attempts (= consumed slots) per task. Same two-leg shape as
+ * getSolverNetOperatorCount; the only delta is selecting maxClaims here.
  */
-const INSTANCE_SUCCESS_COUNTS_QUERY = `
-query InstanceSuccessCounts($solverNetManifestCid: String!, $limit: Int!, $after: String) {
-  verdictEnvelopeMetas(
-    where: {
-      solverNetManifestCid: $solverNetManifestCid,
-      solverType_starts_with: "swe-rebench-v2",
-      actualPassed: true,
-      enrichmentStatus: "ok",
-      instanceId_not: ""
-    },
+const CLAIM_COUNT_TASKS_QUERY = `
+query ClaimCountTasks($manifestDigest: String!, $limit: Int!, $after: String) {
+  tasks(
+    where: { manifestDigest: $manifestDigest },
     limit: $limit,
     after: $after,
-    orderBy: "enrichedAtBlock",
+    orderBy: "id",
     orderDirection: "asc"
   ) {
     items {
-      requestId
+      id
+      maxClaims
       chainId
-      instanceId
     }
     pageInfo {
       hasNextPage
@@ -259,13 +249,13 @@ query InstanceSuccessCounts($solverNetManifestCid: String!, $limit: Int!, $after
 }
 `;
 /**
- * Leg 1 of getInstanceClaimCounts (#802): page every task id + maxClaims for a
- * SolverNet's manifestDigest. Leg 2 reuses ATTEMPTS_FOR_TASKS_QUERY to count
- * attempts (= consumed slots) per task. Same two-leg shape as
- * getSolverNetOperatorCount; the only delta is selecting maxClaims here.
+ * Per-task on-chain finalization snapshot (#579). Pages every task id +
+ * finalized/refunded/claimWindowEnd for a SolverNet's manifestDigest, capped at
+ * MAX_OPERATOR_COUNT_TASK_PAGES like CLAIM_COUNT_TASKS_QUERY. Backs the Launcher
+ * "Recent posted Tasks" status chip — a DISPLAY signal, not a correctness gate.
  */
-const CLAIM_COUNT_TASKS_QUERY = `
-query ClaimCountTasks($manifestDigest: String!, $limit: Int!, $after: String) {
+const TASK_STATUSES_QUERY = `
+query TaskStatuses($manifestDigest: String!, $limit: Int!, $after: String) {
   tasks(
     where: { manifestDigest: $manifestDigest },
     limit: $limit,
@@ -275,8 +265,9 @@ query ClaimCountTasks($manifestDigest: String!, $limit: Int!, $after: String) {
   ) {
     items {
       id
-      maxClaims
-      chainId
+      finalized
+      refunded
+      claimWindowEnd
     }
     pageInfo {
       hasNextPage
@@ -340,85 +331,12 @@ query MostRecentTask($manifestDigest: String!) {
   }
 }
 `;
-const QUERY_ENVELOPES_QUERY = `
-query QueryEnvelopes($where: envelopeFilter, $limit: Int!) {
-  envelopes(
-    where: $where,
-    limit: $limit,
-    orderBy: "publishedAtBlock",
-    orderDirection: "desc"
-  ) {
-    items {
-      agentId
-      manifestCid
-      manifestHash
-      evidenceTier
-      publishedAtBlock
-    }
-  }
-}
-`;
 /** Sentinel for an unenriched / unknown launcher safe address. */
 const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
 /** Coerce an indexer-supplied address to a typed hex, or fall back to the zero sentinel. */
 function safeAddr(a) {
     return typeof a === 'string' && /^0x[0-9a-fA-F]{40}$/.test(a) ? a : ZERO_ADDR;
 }
-// ── Per-codeDigest reward aggregates (#764) ──────────────────────────────────
-const CODEDIGEST_ATTEMPTS_QUERY = `
-query CodeDigestAttempts($codeDigests: [String!]!, $limit: Int!, $after: String) {
-  attemptEnvelopeMetas(
-    where: { codeDigest_in: $codeDigests, mode: "train", enrichmentStatus: "ok" },
-    limit: $limit,
-    after: $after,
-    orderBy: "enrichedAtBlock",
-    orderDirection: "desc"
-  ) {
-    items { requestId chainId codeDigest }
-    pageInfo { hasNextPage endCursor }
-  }
-}
-`;
-// The verdict leg is the only place per-SolverNet scoping is queryable: of the
-// tables this method touches, only `verdictEnvelopeMeta` carries
-// `solverNetManifestCid` (ponder.schema.ts:657 — written by the same IPFS
-// task-body enrichment that resolves instanceId). `attemptEnvelopeMeta` has no
-// SolverNet column. Aggregation (step 4) only counts requests that HAVE a
-// verdict, so filtering the verdict leg correctly scopes the whole aggregate to
-// the given SolverNet. The filter is emitted only when scoping is requested —
-// Ponder treats a `null` `where` value as "IS NULL", not "skip the filter", so
-// an unscoped call must omit the field entirely (#764).
-function codeDigestVerdictsQuery(scopeBySolverNet) {
-    return `
-query CodeDigestVerdicts($requestIds: [String!]!, $limit: Int!, $after: String${scopeBySolverNet ? ', $solverNetManifestCid: String!' : ''}) {
-  verdictEnvelopeMetas(
-    where: { requestId_in: $requestIds${scopeBySolverNet ? ', solverNetManifestCid: $solverNetManifestCid' : ''} },
-    limit: $limit,
-    after: $after,
-    orderBy: "requestId",
-    orderDirection: "asc"
-  ) {
-    items { requestId chainId actualPassed actualScore passedCount totalCount }
-    pageInfo { hasNextPage endCursor }
-  }
-}
-`;
-}
-// Optional operator scoping: restrict attempts to those the operator claimed.
-const CODEDIGEST_OPERATOR_ATTEMPTS_QUERY = `
-query CodeDigestOperatorAttempts($requestIds: [String!]!, $operator: String!, $limit: Int!, $after: String) {
-  attempts(
-    where: { requestId_in: $requestIds, operator: $operator },
-    limit: $limit,
-    after: $after,
-    orderBy: "createdAtBlock",
-    orderDirection: "asc"
-  ) {
-    items { requestId chainId }
-    pageInfo { hasNextPage endCursor }
-  }
-}
-`;
 // ── Plug-in publication queries (attd) ───────────────────────────────────────
 const LIST_PLUGIN_PUBLICATIONS_QUERY = `
 query ListPluginPublications($where: pluginPublicationFilter, $limit: Int!) {
@@ -443,23 +361,6 @@ query ListPluginPublications($where: pluginPublicationFilter, $limit: Int!) {
   }
 }
 `;
-const GET_PLUGIN_SCORES_QUERY = `
-query GetPluginScores($pluginCid: String!, $limit: Int!) {
-  attemptEnvelopeMetas(
-    where: { pluginsContains: $pluginCid },
-    limit: $limit,
-    orderBy: "enrichedAtBlock",
-    orderDirection: "desc"
-  ) {
-    items {
-      requestId
-      manifestCid
-      pluginsJson
-      enrichedAtBlock
-    }
-  }
-}
-`;
 /**
  * How long a `/ready` probe result is trusted before re-probing. Ponder's
  * `/ready` flips to 200 once the indexer has caught up to realtime; before that
@@ -479,15 +380,81 @@ const READY_PROBE_TTL_MS = 20_000;
  * (#1038).
  */
 const FETCH_TIMEOUT_MS = 15_000;
+/**
+ * Default backoff schedule for transparent retries on transient indexer
+ * failures. `[200, 500]` retries twice — worst-case added latency 700ms, under
+ * the 800ms cap (#782 AC#1). Indexer flake (502/503) is bursty: a single
+ * transient 502 otherwise silences a daemon poll for a full poll interval, so
+ * a short transparent retry recovers without surfacing an outage.
+ *
+ * Retry is safe here because every retried POST is a read-only GraphQL *query*
+ * (no mutations in this client), so re-issuing it is idempotent.
+ */
+const RETRY_DELAYS_MS = [200, 500];
 // ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Wrap a fetch with transparent retry on transient indexer failures: 502/503
+ * responses and network-level fetch errors (TCP/TLS/DNS). Retries follow the
+ * `retryDelaysMs` schedule (one retry per entry). On exhaustion the last 502/503
+ * Response is returned unchanged — so `postGql`'s `!response.ok` raiser
+ * preserves the original status — or the last thrown error is re-thrown
+ * unchanged — so the network-path raiser preserves the original cause. Any
+ * non-502/503 response and any non-network outcome is returned/propagated on the
+ * first attempt (NOT retried); GraphQL-level `errors[]` are not visible here
+ * (they arrive in a 200 body) so they are likewise never retried.
+ */
+function fetchWithRetry(baseFetch, retryDelaysMs) {
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    return async (input, init) => {
+        for (let attempt = 0;; attempt++) {
+            try {
+                const res = await baseFetch(input, init);
+                if ((res.status === 502 || res.status === 503) && attempt < retryDelaysMs.length) {
+                    await sleep(retryDelaysMs[attempt]);
+                    continue;
+                }
+                return res;
+            }
+            catch (err) {
+                if (attempt < retryDelaysMs.length) {
+                    await sleep(retryDelaysMs[attempt]);
+                    continue;
+                }
+                throw err;
+            }
+        }
+    };
+}
 function parseOptionalNumber(value) {
     if (typeof value === 'number')
         return Number.isFinite(value) ? value : undefined;
     if (typeof value !== 'string')
         return undefined;
-    const n = Number(value);
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const n = Number(trimmed);
     return Number.isFinite(n) ? n : undefined;
 }
+function parseOptionalBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true')
+            return true;
+        if (normalized === 'false')
+            return false;
+        return undefined;
+    }
+    if (typeof value === 'number') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+    }
+    return undefined;
+}
 function isHex(value) {
     return typeof value === 'string' && /^0x[0-9a-fA-F]+$/.test(value);
 }
@@ -538,6 +505,7 @@ export function createHttpDiscoveryAPI(opts) {
     const readyUrl = `${opts.url.replace(/\/graphql\/?$/, '').replace(/\/$/, '')}/ready`;
     const readyTtlMs = opts.readyProbeTtlMs ?? READY_PROBE_TTL_MS;
     const fetchTimeoutMs = opts.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+    const retryDelaysMs = opts.retryDelaysMs ?? RETRY_DELAYS_MS;
     const baseFetch = opts.fetchImpl ?? globalThis.fetch;
     if (!baseFetch) {
         throw new Error('No fetch implementation available; pass fetchImpl in options');
@@ -550,7 +518,23 @@ export function createHttpDiscoveryAPI(opts) {
     // on-chain (#1038). A timeout turns the hang into the same
     // DiscoveryUnavailableError those loops already catch and retry. A caller
     // that supplies its own signal keeps it.
-    const fetchImpl = (input, init) => baseFetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(fetchTimeoutMs) });
+    //
+    // The AbortSignal-timeout wrap is INSIDE the retry loop (each retry attempt
+    // gets a fresh per-request timeout), and transient 502/503 responses and
+    // network-level fetch errors are transparently retried on the retryDelaysMs
+    // schedule before the failure is allowed to settle. This means a single
+    // bursty indexer flake no longer silences a whole daemon poll (#782); the
+    // bad-state `/ready` cache is also only written once the retrying fetch
+    // settles, so a transient probe blip cannot poison the cache (#782 AC#4).
+    const timeoutFetch = (input, init) => baseFetch(input, { ...init, signal: init?.signal ?? AbortSignal.timeout(fetchTimeoutMs) });
+    const fetchImpl = fetchWithRetry(timeoutFetch, retryDelaysMs);
+    const corpusDiscovery = createHttpCorpusDiscovery({
+        url: opts.url,
+        fetchImpl: baseFetch,
+        readyProbeTtlMs: readyTtlMs,
+        retryDelaysMs,
+        fetchTimeoutMs,
+    });
     // ── /ready probe (memoized with a short TTL) ──────────────────────────────
     // Ponder serves GraphQL with 200 + stale/empty data while still catching up;
     // `/ready` returns non-200 until it is at realtime. The daemon's fallback
@@ -834,35 +818,17 @@ export function createHttpDiscoveryAPI(opts) {
     }
     // ── queryEnvelopes ────────────────────────────────────────────────────────
     async function queryEnvelopes(query) {
-        await ensureReady();
-        const limit = Math.min(500, Math.max(1, query.limit ?? 50));
-        // Build the where object dynamically — only include filters that are set.
-        // A null filter value means "IS NULL" in Ponder, not "skip the filter".
-        // `kind` is not part of CorpusQuery (we return all envelope kinds).
-        // `query.solverType` is intentionally ignored: solverType lives in the IPFS
-        // manifest body, not in the on-chain envelope payload, so the indexer has no
-        // column for it. Callers must filter by solverType client-side after fetching
-        // the IPFS manifests. See packages/indexer/README.md §Known limitations.
-        const where = {};
-        if (query.evidenceTier)
-            where['evidenceTier'] = query.evidenceTier;
-        if (query.manifestHash)
-            where['manifestHash'] = query.manifestHash;
-        const data = await postGql(gqlUrl, fetchImpl, QUERY_ENVELOPES_QUERY, { where, limit });
-        const items = data.envelopes?.items ?? [];
-        // Map to EnvelopeRef. The indexer does not store safeAddress (not in the
-        // IdentityRegistry event); leave it empty. The corpus library enriches it
-        // on retrieval via the IPFS manifest fetch.
-        return items.map((row) => ({
-            manifestCid: row.manifestCid,
-            manifestHash: row.manifestHash,
-            operator: {
-                agentId: row.agentId,
-                safeAddress: '',
-            },
-            evidenceTier: row.evidenceTier ?? 'unknown',
-            publishedAt: Number(row.publishedAtBlock),
-        }));
+        try {
+            return await corpusDiscovery.queryEnvelopes(query);
+        }
+        catch (error) {
+            // Preserve the public client error identity used by withFallback and by
+            // daemon/MCP callers while core owns the HTTP request implementation.
+            if (error instanceof CoreDiscoveryUnavailableError) {
+                throw new DiscoveryUnavailableError(error.message, error.cause);
+            }
+            throw error;
+        }
     }
     // ── listPluginPublications (attd) ─────────────────────────────────────────
     async function listPluginPublications(args) {
@@ -891,45 +857,12 @@ export function createHttpDiscoveryAPI(opts) {
     }
     // ── getPluginScores (attd) ─────────────────────────────────────────────────
     async function getPluginScores(args) {
-        await ensureReady();
-        const limit = Math.min(500, Math.max(1, args.limit ?? 100));
-        try {
-            const data = await postGql(gqlUrl, fetchImpl, GET_PLUGIN_SCORES_QUERY, { pluginCid: args.pluginCid, limit });
-            // ebu7's AttemptEnvelopeMeta carries `pluginsJson` — JSON.stringify of
-            // executor.plugins[]. Parse it and emit one row per matching entry; flag
-            // forkSuspected when the sha256 doesn't match the publication.
-            // For now, return whatever the server returns; full join with verdict +
-            // pluginPublication.sha256 is a §6.5 Discovery API endpoint that lands
-            // alongside the /builders/:agentId/runs Hono route. attd's read-shape
-            // ships the empty-array contract; ebu7 + 6.5 flesh it in.
-            return (data.attemptEnvelopeMetas?.items ?? []).flatMap((row) => {
-                let plugins = [];
-                try {
-                    plugins = JSON.parse(row.pluginsJson);
-                }
-                catch {
-                    return [];
-                }
-                const match = plugins.find((p) => p.cid === args.pluginCid);
-                if (!match)
-                    return [];
-                return [{
-                        pluginCid: args.pluginCid,
-                        taskId: '',
-                        operatorAgentId: '',
-                        verdict: 'Unknown',
-                        ts: Number(row.enrichedAtBlock),
-                        forkSuspected: false,
-                    }];
-            });
-        }
-        catch (err) {
-            // attemptEnvelopeMeta entity not present (ebu7 not deployed yet) → empty.
-            if (err instanceof Error && /attemptEnvelopeMetas|Unknown type|Cannot query/.test(err.message)) {
-                return [];
-            }
-            throw err;
-        }
+        void args;
+        // attemptEnvelopeMeta is a permissionless, shape-parsed projection. Until
+        // the indexer exposes a canonical row authenticated with the historical
+        // publisher Safe, envelope signature/hash, and authoritative attempt,
+        // plugin attribution cannot be treated as verified score history.
+        return [];
     }
     // ── listBuilderArtifacts (attd) ────────────────────────────────────────────
     async function listBuilderArtifacts(args) {
@@ -948,155 +881,21 @@ export function createHttpDiscoveryAPI(opts) {
     // with overlapping instance_id pools from cross-tenant over-counting
     // (#669 Finding 2).
     async function getInstanceSuccessCounts(args) {
-        await ensureReady();
-        // Defensive cap: 10 × 1000 rows. Expected ~125 successes per SolverNet
-        // (25 candidates × N_target_successes), so two orders of magnitude head.
-        const MAX_PAGES = 10;
-        const PAGE_LIMIT = 1000;
-        const counts = new Map();
-        const seen = new Set(); // (requestId|chainId) dedupe across pages
-        let cursor = null;
-        for (let page = 0; page < MAX_PAGES; page++) {
-            const data = await postGql(gqlUrl, fetchImpl, INSTANCE_SUCCESS_COUNTS_QUERY, { solverNetManifestCid: args.manifestCid, limit: PAGE_LIMIT, after: cursor });
-            const rows = data.verdictEnvelopeMetas?.items ?? [];
-            for (const row of rows) {
-                const key = `${row.requestId}|${row.chainId}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const id = row.instanceId;
-                if (!id)
-                    continue;
-                counts.set(id, (counts.get(id) ?? 0) + 1);
-            }
-            const pageInfo = data.verdictEnvelopeMetas?.pageInfo;
-            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
-                break;
-            cursor = pageInfo.endCursor;
-        }
-        return counts;
+        void args;
+        // A unique verdictEnvelopeMeta row is not evidence: any ERC-8004 publisher
+        // can project a fresh requestId, victim instance, and passing outcome. Keep
+        // the launcher on its local counters until canonical bridge-grade verdict
+        // authentication is materialized by the indexer.
+        return new Map();
     }
     async function getCodeDigestRewards(args) {
         if (args.codeDigests.length === 0)
             return [];
-        await ensureReady();
-        const MAX_PAGES = 20;
-        const PAGE_LIMIT = 1000;
-        // Per-digest recency cap (#764 C1). CODEDIGEST_ATTEMPTS_QUERY orders by
-        // enrichedAtBlock desc, so attempt rows arrive newest-first. Ponder's
-        // GraphQL `limit` is global across all requested codeDigests, so the window
-        // MUST be enforced client-side per-digest — we keep only the first `window`
-        // rows seen for each codeDigest (i.e. the most recent). When undefined, no
-        // cap is applied (behaviour identical to before this change).
-        const windowCap = typeof args.window === 'number' && Number.isFinite(args.window) && args.window > 0
-            ? Math.floor(args.window)
-            : undefined;
-        // 1) Pull train-mode attempt-meta rows for the requested codeDigests,
-        //    capped to the most-recent `window` per codeDigest when set.
-        const requestKeyToDigest = new Map(); // "requestId|chainId" -> codeDigest
-        const keptPerDigest = new Map(); // codeDigest -> rows kept
-        let cursor = null;
-        for (let page = 0; page < MAX_PAGES; page++) {
-            const data = await postGql(gqlUrl, fetchImpl, CODEDIGEST_ATTEMPTS_QUERY, { codeDigests: args.codeDigests, limit: PAGE_LIMIT, after: cursor });
-            for (const row of data.attemptEnvelopeMetas?.items ?? []) {
-                if (windowCap !== undefined) {
-                    const kept = keptPerDigest.get(row.codeDigest) ?? 0;
-                    if (kept >= windowCap)
-                        continue; // already have the window's worth for this digest
-                    keptPerDigest.set(row.codeDigest, kept + 1);
-                }
-                requestKeyToDigest.set(`${row.requestId}|${row.chainId}`, row.codeDigest);
-            }
-            const pi = data.attemptEnvelopeMetas?.pageInfo;
-            if (!pi?.hasNextPage || !pi.endCursor)
-                break;
-            // Short-circuit pagination once every requested digest has filled its
-            // window — no need to keep paging history we'll discard.
-            if (windowCap !== undefined &&
-                args.codeDigests.every((d) => (keptPerDigest.get(d) ?? 0) >= windowCap))
-                break;
-            cursor = pi.endCursor;
-        }
-        if (requestKeyToDigest.size === 0)
-            return [];
-        const requestIds = [...new Set([...requestKeyToDigest.keys()].map((k) => k.split('|')[0]))];
-        // 2) Optional operator scoping: keep only requests the operator claimed.
-        let allowedKeys = null;
-        if (args.operator) {
-            allowedKeys = new Set();
-            cursor = null;
-            for (let page = 0; page < MAX_PAGES; page++) {
-                const data = await postGql(gqlUrl, fetchImpl, CODEDIGEST_OPERATOR_ATTEMPTS_QUERY, { requestIds, operator: args.operator, limit: PAGE_LIMIT, after: cursor });
-                for (const row of data.attempts?.items ?? [])
-                    allowedKeys.add(`${row.requestId}|${row.chainId}`);
-                const pi = data.attempts?.pageInfo;
-                if (!pi?.hasNextPage || !pi.endCursor)
-                    break;
-                cursor = pi.endCursor;
-            }
-        }
-        // 3) Pull verdict-meta rows for those requestIds (actualPassed/actualScore).
-        // Optionally scope to a single SolverNet: verdictEnvelopeMeta is the only
-        // queryable table carrying solverNetManifestCid, and only requests with a
-        // verdict are aggregated (step 4), so filtering here scopes the aggregate.
-        const scopeBySolverNet = typeof args.solverNetManifestCid === 'string' && args.solverNetManifestCid.length > 0;
-        const verdictsQuery = codeDigestVerdictsQuery(scopeBySolverNet);
-        const verdictByKey = new Map();
-        cursor = null;
-        for (let page = 0; page < MAX_PAGES; page++) {
-            const variables = { requestIds, limit: PAGE_LIMIT, after: cursor };
-            if (scopeBySolverNet)
-                variables.solverNetManifestCid = args.solverNetManifestCid;
-            const data = await postGql(gqlUrl, fetchImpl, verdictsQuery, variables);
-            for (const row of data.verdictEnvelopeMetas?.items ?? []) {
-                const key = `${row.requestId}|${row.chainId}`;
-                const scoreNum = Number(row.actualScore);
-                const pc = Number(row.passedCount);
-                const tc = Number(row.totalCount);
-                const graded = Number.isFinite(tc) && tc > 0 ? pc / tc : null;
-                verdictByKey.set(key, {
-                    passed: Boolean(row.actualPassed),
-                    score: Number.isFinite(scoreNum) && row.actualScore !== '' ? scoreNum : null,
-                    graded,
-                });
-            }
-            const pi = data.verdictEnvelopeMetas?.pageInfo;
-            if (!pi?.hasNextPage || !pi.endCursor)
-                break;
-            cursor = pi.endCursor;
-        }
-        // 4) Aggregate per codeDigest (only requests that HAVE a verdict count).
-        const agg = new Map();
-        for (const [key, digest] of requestKeyToDigest) {
-            if (allowedKeys && !allowedKeys.has(key))
-                continue;
-            const v = verdictByKey.get(key);
-            if (!v)
-                continue; // no verdict yet — not a completed attempt
-            const cur = agg.get(digest) ?? { attempts: 0, passes: 0, scoreSum: 0, scoreN: 0, gradedScores: [] };
-            cur.attempts += 1;
-            if (v.passed)
-                cur.passes += 1;
-            if (v.score !== null) {
-                cur.scoreSum += v.score;
-                cur.scoreN += 1;
-            }
-            if (v.graded !== null)
-                cur.gradedScores.push(v.graded);
-            agg.set(digest, cur);
-        }
-        const rows = [];
-        for (const [codeDigest, a] of agg) {
-            rows.push({
-                codeDigest,
-                attempts: a.attempts,
-                passes: a.passes,
-                passRate: a.attempts > 0 ? a.passes / a.attempts : 0,
-                avgScore: a.scoreN > 0 ? a.scoreSum / a.scoreN : 0,
-                gradedScores: a.gradedScores,
-            });
-        }
-        return rows;
+        // Shape-parsed attempt/verdict projections are not authenticated reward
+        // evidence. Returning no verified rows keeps the learner and revert gate
+        // conservative; a future canonical route must bind publisher Safe,
+        // signature/hash, authoritative chain tuple, and original task facts.
+        return [];
     }
     // ── getInstanceClaimCounts (#802) ──────────────────────────────────────────
     // Per-task consumed-vs-maxClaims for a SolverNet. Two legs, mirroring
@@ -1210,6 +1009,48 @@ export function createHttpDiscoveryAPI(opts) {
             return undefined;
         return { taskCidDigest: row.taskCidDigest, taskId: row.id };
     }
+    // ── getTaskStatuses (#579) ─────────────────────────────────────────────────
+    // Per-task finalized/refunded/claimWindowEnd for a SolverNet, keyed by taskId.
+    // Single leg, mirroring getInstanceClaimCounts leg 1: page tasks for the
+    // manifestDigest, capped at MAX_OPERATOR_COUNT_TASK_PAGES.
+    async function getTaskStatuses(args) {
+        await ensureReady();
+        const manifestDigest = manifestDigestForCid(args.manifestCid).toLowerCase();
+        const out = new Map();
+        let taskCursor = null;
+        for (let page = 0; page < MAX_OPERATOR_COUNT_TASK_PAGES; page++) {
+            const data = await postGql(gqlUrl, fetchImpl, TASK_STATUSES_QUERY, { manifestDigest, limit: ATTEMPTS_PAGE_LIMIT, after: taskCursor });
+            for (const row of data.tasks?.items ?? []) {
+                const finalized = parseOptionalBoolean(row.finalized);
+                const refunded = parseOptionalBoolean(row.refunded);
+                if (finalized === undefined || refunded === undefined)
+                    continue;
+                const claimWindowEnd = parseOptionalNumber(row.claimWindowEnd);
+                out.set(row.id, {
+                    taskId: row.id,
+                    finalized,
+                    refunded,
+                    claimWindowEnd,
+                });
+            }
+            const pageInfo = data.tasks?.pageInfo;
+            if (!pageInfo?.hasNextPage || !pageInfo.endCursor)
+                break;
+            taskCursor = pageInfo.endCursor;
+        }
+        return out;
+    }
+    // ── getVerdictTallies (#502) ───────────────────────────────────────────────
+    // Resolved PASS/FAIL tallies per task, grouped client-side (Ponder has no
+    // GROUP BY). DISPLAY signal backing the Activity Outcome column. Dedupes on
+    // (requestId|chainId); folds PASS→pass, FAIL→fail; excludes
+    // INVALID/INDETERMINATE/UNKNOWN. Empty taskIds short-circuits with no query.
+    async function getVerdictTallies(args) {
+        void args;
+        // The on-chain fallback still exposes authoritative delivery state. Do not
+        // decorate it with unauthenticated off-chain polarity projections.
+        return new Map();
+    }
     return {
         findClaimableTasks,
         listLaunchedSolverNets,
@@ -1224,6 +1065,8 @@ export function createHttpDiscoveryAPI(opts) {
         getInstanceClaimCounts,
         getTaskPostCounts,
         getMostRecentTaskCidDigest,
+        getTaskStatuses,
+        getVerdictTallies,
     };
 }
 //# sourceMappingURL=http.js.map