@jinn-network/client 0.1.9 → 0.2.0

package/dist/api/gather-status.js

@@ -1,26 +1,26 @@
 /**
  * Best-effort status collection for GET /v1/status (RPC + earning store + SQLite).
  */
-import { createPublicClient, getAddress, http, parseAbiItem } from 'viem';
-import { existsSync, readFileSync } from 'node:fs';
+import { createPublicClient, http } from 'viem';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { base, baseSepolia } from 'viem/chains';
-import { isOverSpendCap } from '../daemon/spend-cap-gate.js';
+import { base, baseSepolia, sepolia } from 'viem/chains';
+import { isOverSpendCap } from '../spend/spend-cap.js';
 import { blockResetsAtUtc, weekResetsAtUtc, GPT_5_4_MINI_USD_PER_BLOCK } from '../spend/ai-units.js';
 import { FleetStateStore } from '../earning/store.js';
-import { DEFAULT_TESTNET_ARTIFACTS, getChainConfig, loadJinnMviConfig, } from '../earning/contracts.js';
-import { createJinnL1PublicClient } from '../earning/viem-clients.js';
+import { getChainConfig, } from '../earning/contracts.js';
 import { stage1MinMasterEth } from '../earning/bootstrap.js';
-import { JINN_STAKING_ABI } from '../earning/jinn-rewards.js';
+import { JINN_STAKING_ABI } from '../earning/stolas-staking.js';
 import { displayFleetServiceIndex } from '../earning/fleet-display-index.js';
-import { assembleStatusV1, pendingTjinnStatus, TJINN_PUBLIC_INVALID_SAFE_ERROR, TJINN_PUBLIC_PARTIAL_ERROR, TJINN_PUBLIC_READ_ERROR, resolveMasterDailyEstimateWei, } from './status-build.js';
+import { assembleStatusV1, resolveMasterDailyEstimateWei, } from './status-build.js';
 import { listStolasClaimTargets } from '../earning/stolas-claim.js';
 import { gatherPortfolioV0Status, DEFAULT_ENGINE_WORKING_DIR_ROOT, } from './portfolio-v0-build.js';
 import { gatherPredictionV1Status, } from './prediction-v1-build.js';
-import { gatherTaskRunsStatus } from './task-runs-build.js';
+import { gatherTaskRunsStatus, applyOutcomes } from './task-runs-build.js';
 import { gatherLoopCompletion, gatherImplStateCadence } from './loop-completion-build.js';
+import { buildInfo } from '../build-info.js';
 import { buildPredictionOperatorStatus, } from '../solver-nets/prediction-operator-ux.js';
-import { findJoinedByName, rolesFromJoinedConfig, solverTypeFromJoinedContract, } from '../solver-nets/registry.js';
+import { findJoinedByName, joinedDisplayName, rolesFromJoinedConfig, solverTypeFromJoinedContract, } from '../solver-nets/registry.js';
 import { buildHarnessRollup } from './status-harness-rollup.js';
 const ERC20_BALANCE_OF_ABI = [
     {
@@ -31,81 +31,11 @@ const ERC20_BALANCE_OF_ABI = [
         outputs: [{ name: '', type: 'uint256' }],
     },
 ];
-const JINN_DISTRIBUTOR_CLAIMED_ABI = [
-    {
-        type: 'function',
-        name: 'totalClaimedOperator',
-        stateMutability: 'view',
-        inputs: [{ name: 'serviceId', type: 'uint256' }],
-        outputs: [{ name: '', type: 'uint256' }],
-    },
-];
-/**
- * `Claimed` event item for `getLogs({ event, args })`. Matches the
- * Solidity signature in
- * `contracts/src/jinn/distribution/JinnDistributor.sol` so the operator
- * 24h-minted sum can be computed without a separate indexer.
- */
-const JINN_DISTRIBUTOR_CLAIMED_EVENT = parseAbiItem('event Claimed(uint256 indexed serviceId, address indexed multisig, uint256 operatorMinted, uint256 daoMinted, uint256 totalEntitledOperator, uint256 totalEntitledDao)');
-const TJINN_BALANCE_CACHE_TTL_MS = 30_000;
-const TJINN_BALANCE_TIMEOUT_MS = 6_000;
-/**
- * Approximate Sepolia blocks per 24 hours. The chain produces a block every
- * ~12s; 86_400 / 12 = 7_200. We pad to 7_500 to absorb the occasional
- * slower block and keep the window comfortably within the common 10k-block
- * `eth_getLogs` cap.
- */
-const SEPOLIA_BLOCKS_PER_24H = 7500n;
-/**
- * tJINN token address + chain id resolved from the bundled JINN MVI L1
- * deployment artifact — the single source of truth. Used only when the caller
- * (`main.ts`) does not thread explicit values through `StatusGatherConfig`
- * (e.g. test callers, sqlite-only introspection without config). Lazy + cached
- * so the artifact read happens at most once per process.
- */
-let cachedTjinnArtifactIdentity;
-function defaultTjinnIdentity() {
-    if (!cachedTjinnArtifactIdentity) {
-        let tokenAddress;
-        let chainId;
-        try {
-            const mvi = loadJinnMviConfig({ l1ArtifactPath: DEFAULT_TESTNET_ARTIFACTS.jinnMviL1 });
-            tokenAddress = mvi.jinn;
-            chainId = mvi.l1ChainId;
-        }
-        catch {
-            // Fall through to the hard defaults below if the artifact is unreadable.
-        }
-        cachedTjinnArtifactIdentity = {
-            tokenAddress: tokenAddress ?? '0x0bc0B2f733bF4229FD58Baaac5ebFEf2AEc83C4A',
-            chainId: chainId ?? 11155111,
-        };
-    }
-    return cachedTjinnArtifactIdentity;
-}
-function resolveTjinnIdentity(status) {
-    const fallback = defaultTjinnIdentity();
-    return {
-        tokenAddress: status?.tjinnTokenAddress ?? fallback.tokenAddress,
-        chainId: status?.tjinnChainId ?? fallback.chainId,
-    };
-}
-/** Fill a fresh errors Map with `TJINN_PUBLIC_READ_ERROR` for every key. */
-function errorsForAllKeys(keys) {
-    const errors = new Map();
-    for (const key of keys) {
-        errors.set(key, TJINN_PUBLIC_READ_ERROR);
-    }
-    return errors;
-}
-function errorsForAllServiceIds(serviceIds) {
-    const errors = new Map();
-    for (const serviceId of serviceIds) {
-        errors.set(serviceId, TJINN_PUBLIC_READ_ERROR);
-    }
-    return errors;
-}
-const tjinnBalanceCache = new Map();
+// The tokenless-OLAS configuration no longer carries an Ethereum-L1 RPC
+// surface. The operator dashboard still needs the Sepolia master-gas runway on
+// testnet, so this read uses the public endpoint directly; failures remain
+// status-only and suppress runway severity rather than blocking the daemon.
+const TESTNET_ETHEREUM_RPC_URL = 'https://ethereum-sepolia-rpc.publicnode.com';
 function readDaemonRuntime(earningDir) {
     if (!earningDir)
         return undefined;
@@ -125,6 +55,21 @@ function readDaemonRuntime(earningDir) {
         return { pidPath, pid, alive: false, stale: true };
     }
 }
+/**
+ * Resolve `security.lastPasswordRotationAt` from the password provenance
+ * descriptor. File mtime is read at request time. Never throws: a missing,
+ * unreadable, or env-sourced password yields `null` (issue #441).
+ */
+function resolvePasswordRotationAt(cfg) {
+    if (!cfg || cfg.source === 'env' || !cfg.filePath)
+        return null;
+    try {
+        return statSync(cfg.filePath).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
 const predictionOperatorStatusCache = new WeakMap();
 /**
  * Drop any cached prediction operator status for `config`.
@@ -146,18 +91,20 @@ function chainKey(network) {
 /**
  * Derive the SolverNet name to use for the prediction operator diagnostic.
  *
- * Priority: (1) first joined entry's `name` field, (2) first joined entry's
- * manifestCid, (3) fallback `'prediction'`.
+ * Only a joined entry whose `contract.id === 'prediction'` names the
+ * prediction SolverNet — returns its `name` (or, if unnamed, its manifestCid
+ * map key). If the operator has joined no prediction SolverNet (the normal
+ * case post-deprecation), returns the literal `'prediction'` rather than
+ * mislabeling some other joined net (#446).
  *
  * Post-issue-#421 the legacy `solverNets` config block has been retired; the
  * operator's participation choices live in `joinedSolverNets` keyed by
- * manifestCid.
+ * manifestCid, with migrated-legacy entries carrying a populated `contract`.
  */
-function derivePredictionSolverNetName(config) {
-    const joinedEntries = Object.entries(config.joinedSolverNets ?? {});
-    if (joinedEntries.length > 0) {
-        const [cid, entry] = joinedEntries[0];
-        return entry.name ?? cid;
+export function derivePredictionSolverNetName(config) {
+    for (const [cid, entry] of Object.entries(config.joinedSolverNets ?? {})) {
+        if (entry.contract?.id === 'prediction')
+            return joinedDisplayName(cid, entry);
     }
     return 'prediction';
 }
@@ -280,158 +227,6 @@ function predictionV1Unavailable(operator, operatorError) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function tJinnBalanceCacheKey(ethereumRpcUrl, distributorAddress, safeKeys, serviceIds) {
-    return [
-        ethereumRpcUrl,
-        distributorAddress ?? '',
-        [...safeKeys].sort().join(','),
-        [...serviceIds].sort((a, b) => a - b).join(','),
-    ].join('\0');
-}
-function timeoutError(message) {
-    const error = new Error(message);
-    error.name = 'TimeoutError';
-    return error;
-}
-function withTimeout(promise, timeoutMs, message) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(timeoutError(message)), timeoutMs);
-        promise
-            .then(resolve, reject)
-            .finally(() => clearTimeout(timer));
-    });
-}
-async function readTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, serviceIds) {
-    const safeEntries = [...safeToAddress.entries()];
-    const client = createJinnL1PublicClient(ethereumRpcUrl, 'sepolia');
-    const chainId = await client.getChainId();
-    const balances = new Map();
-    const operatorClaimedByService = new Map();
-    const operatorMintedLast24hByService = new Map();
-    if (chainId !== expectedChainId) {
-        return {
-            chainId,
-            balances,
-            operatorClaimedByService,
-            operatorMintedLast24hByService,
-            errors: errorsForAllKeys(safeToAddress.keys()),
-            claimedErrors: errorsForAllServiceIds(serviceIds),
-            claimedLast24hError: TJINN_PUBLIC_READ_ERROR,
-        };
-    }
-    const errors = new Map();
-    // Single multicall3 round-trip (Sepolia has multicall3). `allowFailure: true`
-    // preserves the per-Safe partial-failure handling — a failed entry yields a
-    // `{ status: 'failure' }` result rather than rejecting the whole batch.
-    const results = await client.multicall({
-        allowFailure: true,
-        contracts: safeEntries.map(([, safeAddress]) => ({
-            address: tokenAddress,
-            abi: ERC20_BALANCE_OF_ABI,
-            functionName: 'balanceOf',
-            args: [safeAddress],
-        })),
-    });
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        const key = safeEntries[i]?.[0];
-        if (!key)
-            continue;
-        if (result.status === 'success') {
-            balances.set(key, result.result.toString());
-        }
-        else {
-            errors.set(key, TJINN_PUBLIC_READ_ERROR);
-        }
-    }
-    const claimedErrors = new Map();
-    if (distributorAddress && serviceIds.length > 0) {
-        const claimedResults = await client.multicall({
-            allowFailure: true,
-            contracts: serviceIds.map((serviceId) => ({
-                address: distributorAddress,
-                abi: JINN_DISTRIBUTOR_CLAIMED_ABI,
-                functionName: 'totalClaimedOperator',
-                args: [BigInt(serviceId)],
-            })),
-        });
-        for (let i = 0; i < claimedResults.length; i++) {
-            const serviceId = serviceIds[i];
-            if (serviceId === undefined)
-                continue;
-            const result = claimedResults[i];
-            if (result.status === 'success') {
-                operatorClaimedByService.set(serviceId, result.result.toString());
-            }
-            else {
-                claimedErrors.set(serviceId, TJINN_PUBLIC_READ_ERROR);
-            }
-        }
-    }
-    let claimedLast24hError = null;
-    if (distributorAddress && serviceIds.length > 0) {
-        try {
-            const latest = await client.getBlockNumber();
-            const fromBlock = latest > SEPOLIA_BLOCKS_PER_24H ? latest - SEPOLIA_BLOCKS_PER_24H : 0n;
-            const logs = await client.getLogs({
-                address: distributorAddress,
-                event: JINN_DISTRIBUTOR_CLAIMED_EVENT,
-                args: { serviceId: serviceIds.map((id) => BigInt(id)) },
-                fromBlock,
-                toBlock: latest,
-            });
-            const sums = new Map();
-            for (const log of logs) {
-                const args = log.args;
-                if (args.serviceId === undefined || args.operatorMinted === undefined)
-                    continue;
-                const id = Number(args.serviceId);
-                sums.set(id, (sums.get(id) ?? 0n) + args.operatorMinted);
-            }
-            for (const serviceId of serviceIds) {
-                operatorMintedLast24hByService.set(serviceId, (sums.get(serviceId) ?? 0n).toString());
-            }
-        }
-        catch {
-            claimedLast24hError = TJINN_PUBLIC_READ_ERROR;
-        }
-    }
-    return {
-        chainId,
-        balances,
-        operatorClaimedByService,
-        operatorMintedLast24hByService,
-        errors,
-        claimedErrors,
-        claimedLast24hError,
-    };
-}
-async function getCachedTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, serviceIds) {
-    const safeKeys = [...safeToAddress.keys()].sort();
-    const sortedServiceIds = [...serviceIds].sort((a, b) => a - b);
-    const cacheKey = tJinnBalanceCacheKey(ethereumRpcUrl, distributorAddress, safeKeys, sortedServiceIds);
-    const now = Date.now();
-    const cached = tjinnBalanceCache.get(cacheKey);
-    if (cached && cached.expiresAt > now) {
-        return cached.promise;
-    }
-    const promise = withTimeout(readTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, expectedChainId, safeToAddress, sortedServiceIds), TJINN_BALANCE_TIMEOUT_MS, 'tJINN balance collection timed out').catch(() => {
-        return {
-            chainId: expectedChainId,
-            balances: new Map(),
-            operatorClaimedByService: new Map(),
-            operatorMintedLast24hByService: new Map(),
-            errors: errorsForAllKeys(safeKeys),
-            claimedErrors: errorsForAllServiceIds(sortedServiceIds),
-            claimedLast24hError: TJINN_PUBLIC_READ_ERROR,
-        };
-    });
-    tjinnBalanceCache.set(cacheKey, {
-        expiresAt: now + TJINN_BALANCE_CACHE_TTL_MS,
-        promise,
-    });
-    return promise;
-}
 export async function sumPendingStakingRewards(rpcUrl, network, fleet) {
     const targets = listStolasClaimTargets(fleet.services);
     if (targets.length === 0) {
@@ -483,158 +278,6 @@ export async function sumPendingStakingRewards(rpcUrl, network, fleet) {
         return { error: e instanceof Error ? e.message : String(e) };
     }
 }
-/**
- * Resolve the public error string for a tJINN status with at least one error.
- *
- * Flattened from a 3-deep nested ternary into guard clauses:
- *  - partial success (some balances read) → PARTIAL
- *  - only invalid-Safe errors             → INVALID_SAFE
- *  - otherwise (RPC read failures)        → READ_ERROR
- *
- * Caller must only invoke this when `hasInvalidSafe || hasReadError` is true.
- */
-function tjinnPublicError(opts) {
-    if (opts.hasAnyBalance)
-        return TJINN_PUBLIC_PARTIAL_ERROR;
-    if (opts.hasInvalidSafe && !opts.hasReadError)
-        return TJINN_PUBLIC_INVALID_SAFE_ERROR;
-    return TJINN_PUBLIC_READ_ERROR;
-}
-async function gatherTjinnStatus(ethereumRpcUrl, tokenAddress, distributorAddress, chainId, fleet) {
-    if (!fleet) {
-        return pendingTjinnStatus(tokenAddress, chainId);
-    }
-    const services = [];
-    const safeToAddress = new Map();
-    const serviceIds = new Set();
-    for (const svc of fleet.services) {
-        const index = displayFleetServiceIndex(svc);
-        const serviceId = svc.service_id ?? null;
-        if (serviceId !== null) {
-            serviceIds.add(serviceId);
-        }
-        const safeAddress = svc.safe_address;
-        if (!safeAddress) {
-            services.push({
-                index,
-                serviceId,
-                safeAddress: null,
-                balanceWei: null,
-                operatorClaimedWei: null,
-                state: 'pending',
-                error: null,
-            });
-            continue;
-        }
-        try {
-            const checksum = getAddress(safeAddress);
-            const key = checksum.toLowerCase();
-            services.push({
-                index,
-                serviceId,
-                safeAddress: checksum,
-                balanceWei: null,
-                operatorClaimedWei: null,
-                state: 'pending',
-                error: null,
-            });
-            safeToAddress.set(key, checksum);
-        }
-        catch {
-            services.push({
-                index,
-                serviceId,
-                safeAddress,
-                balanceWei: null,
-                operatorClaimedWei: null,
-                state: 'error',
-                error: TJINN_PUBLIC_INVALID_SAFE_ERROR,
-            });
-        }
-    }
-    const safeCount = safeToAddress.size;
-    if (safeCount === 0) {
-        const invalid = services.find((svc) => svc.state === 'error')?.error;
-        return pendingTjinnStatus(tokenAddress, chainId, {
-            state: invalid ? 'error' : 'pending',
-            safeCount,
-            services,
-            error: invalid ?? null,
-        });
-    }
-    if (!ethereumRpcUrl) {
-        return pendingTjinnStatus(tokenAddress, chainId, { safeCount, services });
-    }
-    const snapshot = await getCachedTjinnBalances(ethereumRpcUrl, tokenAddress, distributorAddress, chainId, safeToAddress, [...serviceIds]);
-    let total = 0n;
-    for (const balance of snapshot.balances.values()) {
-        total += BigInt(balance);
-    }
-    const allClaimedReadsAvailable = !!distributorAddress &&
-        serviceIds.size > 0 &&
-        snapshot.claimedErrors.size === 0 &&
-        [...serviceIds].every((serviceId) => snapshot.operatorClaimedByService.has(serviceId));
-    let operatorClaimedWei = null;
-    if (allClaimedReadsAvailable) {
-        let claimedTotal = 0n;
-        for (const serviceId of serviceIds) {
-            claimedTotal += BigInt(snapshot.operatorClaimedByService.get(serviceId) ?? '0');
-        }
-        operatorClaimedWei = claimedTotal.toString();
-    }
-    // 24h-window sum: null when the log query errored or there are no services.
-    let operatorMintedLast24hWei = null;
-    if (!!distributorAddress &&
-        serviceIds.size > 0 &&
-        snapshot.claimedLast24hError === null) {
-        let last24hTotal = 0n;
-        for (const serviceId of serviceIds) {
-            last24hTotal += BigInt(snapshot.operatorMintedLast24hByService.get(serviceId) ?? '0');
-        }
-        operatorMintedLast24hWei = last24hTotal.toString();
-    }
-    const hasInvalidSafe = services.some((svc) => svc.error === TJINN_PUBLIC_INVALID_SAFE_ERROR);
-    const hasReadError = snapshot.errors.size > 0;
-    const hasAnyError = hasInvalidSafe || hasReadError;
-    const hasAnyBalance = snapshot.balances.size > 0;
-    const publicError = hasAnyError
-        ? tjinnPublicError({ hasInvalidSafe, hasReadError, hasAnyBalance })
-        : null;
-    return pendingTjinnStatus(tokenAddress, snapshot.chainId, {
-        state: hasAnyError ? 'error' : 'ready',
-        safeBalanceWei: hasAnyBalance ? total.toString() : null,
-        operatorClaimedWei,
-        operatorMintedLast24hWei,
-        safeCount,
-        services: services.map((svc) => {
-            const operatorClaimedForService = svc.serviceId !== null
-                ? (snapshot.operatorClaimedByService.get(svc.serviceId) ?? null)
-                : null;
-            if (!svc.safeAddress)
-                return { ...svc, operatorClaimedWei: operatorClaimedForService };
-            if (svc.state === 'error')
-                return { ...svc, operatorClaimedWei: operatorClaimedForService };
-            const key = svc.safeAddress.toLowerCase();
-            const balance = snapshot.balances.get(key);
-            if (balance !== undefined) {
-                return {
-                    ...svc,
-                    state: 'ready',
-                    balanceWei: balance,
-                    operatorClaimedWei: operatorClaimedForService,
-                    error: null,
-                };
-            }
-            return {
-                ...svc,
-                state: 'error',
-                operatorClaimedWei: operatorClaimedForService,
-                error: snapshot.errors.get(key) ?? TJINN_PUBLIC_READ_ERROR,
-            };
-        }),
-        error: publicError,
-    });
-}
 function hasUsefulCacheValues(entry, isAgentRole) {
     if (isAgentRole)
         return entry.nativeWei != null;
@@ -756,23 +399,43 @@ export async function gatherGatheredStatusRaw(store, status) {
         outcome: row.outcome,
     }));
     const lastRewardClaimTickAt = store.getConfigValue('last_reward_claim_tick_at');
+    const taskRunReadModel = store.taskRunReadModel();
     const daily = resolveMasterDailyEstimateWei(status?.masterEthDailyEstimateWei, status?.pollIntervalMs ?? 5000);
-    const tjinnIdentity = resolveTjinnIdentity(status);
     // portfolio.v0 lifecycle data — best-effort, never throws
     let portfolioV0;
     try {
-        portfolioV0 = gatherPortfolioV0Status(store, status?.engine?.workingDirRoot ?? DEFAULT_ENGINE_WORKING_DIR_ROOT);
+        portfolioV0 = gatherPortfolioV0Status(taskRunReadModel, store, status?.engine?.workingDirRoot ?? DEFAULT_ENGINE_WORKING_DIR_ROOT);
     }
     catch {
         portfolioV0 = undefined;
     }
     let taskRuns;
     try {
-        taskRuns = gatherTaskRunsStatus(store);
+        taskRuns = gatherTaskRunsStatus(taskRunReadModel);
     }
     catch {
         taskRuns = undefined;
     }
+    // Enrich task-relative outcomes from the network's verdict tallies
+    // (spec/2026-05-22-run-outcome.md). DISPLAY signal — degrade silently to
+    // null on any discovery failure; never surface a wrong 'fail'.
+    if (taskRuns && status?.discovery) {
+        try {
+            const solveTaskIds = [
+                ...new Set([...taskRuns.recentTasks, ...taskRuns.inFlight]
+                    .filter((r) => r.taskRole !== 'evaluation' && r.state === 'COMPLETE' && r.taskId)
+                    .map((r) => r.taskId)),
+            ];
+            const tallies = solveTaskIds.length
+                ? await status.discovery.getVerdictTallies({ taskIds: solveTaskIds })
+                : new Map();
+            applyOutcomes(taskRuns.recentTasks, tallies);
+            applyOutcomes(taskRuns.inFlight, tallies);
+        }
+        catch {
+            // Outcomes stay null → SPA renders '—'/'awaiting'.
+        }
+    }
     let harnessRollup;
     try {
         const hr = status?.harnessReadiness?.();
@@ -798,7 +461,7 @@ export async function gatherGatheredStatusRaw(store, status) {
     }
     let predictionV1;
     try {
-        predictionV1 = gatherPredictionV1Status(store, {
+        predictionV1 = gatherPredictionV1Status(taskRunReadModel, {
             operator: predictionOperator,
             operatorError: predictionOperatorError,
         });
@@ -809,10 +472,23 @@ export async function gatherGatheredStatusRaw(store, status) {
             ? `${predictionOperatorError}; prediction lifecycle unavailable: ${lifecycleError}`
             : `Prediction lifecycle unavailable: ${lifecycleError}`);
     }
+    // Version-check surface (issue #641). `version` is always this build's
+    // implVersion; `latestVersion` is a best-effort deref of the npm-registry
+    // getter — any failure degrades to null (no banner), never throws.
+    let latestVersion = null;
+    try {
+        latestVersion = status?.latestVersion?.() ?? null;
+    }
+    catch {
+        latestVersion = null;
+    }
     const baseRaw = {
         shutdownState,
+        version: buildInfo.implVersion,
+        latestVersion,
         daemonRuntime: readDaemonRuntime(status?.earningDir),
         daemonStartedAt,
+        passwordRotationAt: resolvePasswordRotationAt(status?.passwordRotation),
         dbPath: store.path,
         earningDir: status?.earningDir,
         activityCounts,
@@ -830,9 +506,7 @@ export async function gatherGatheredStatusRaw(store, status) {
         serviceBalances: {},
         pendingByService: {},
         claimedByService: store.getClaimedRewardsByService(),
-        tjinnTokenAddress: tjinnIdentity.tokenAddress,
-        tjinnChainId: tjinnIdentity.chainId,
-        tjinnDistributorAddress: status?.tjinnDistributorAddress,
+        claimedStakingRewardsLast24hWei: store.getClaimedRewardsLast24hWei(),
         harnessRollup,
     };
     if (!status) {
@@ -848,11 +522,6 @@ export async function gatherGatheredStatusRaw(store, status) {
         testnetMechDeploymentPath: status.testnetMechDeploymentPath,
         testnetStolasDeploymentPath: status.testnetStolasDeploymentPath,
     });
-    // Start the Sepolia tJINN read up front so it overlaps the Base-RPC fan-out
-    // below for free. `gatherTjinnStatus` is internally error-safe (it catches
-    // and returns a snapshot), so the promise never rejects — it is awaited at
-    // the point its result is assigned to `raw.tJinn`.
-    const tJinnPromise = gatherTjinnStatus(status.network === 'testnet' ? status.config?.ethereumRpcUrl : undefined, tjinnIdentity.tokenAddress, status.tjinnDistributorAddress, tjinnIdentity.chainId, fleet);
     const raw = {
         ...baseRaw,
         fleet,
@@ -886,8 +555,7 @@ export async function gatherGatheredStatusRaw(store, status) {
     // that predicate changes (evictionCheckIntervalMs > 0 && stakingMode ===
     // 'standard' && !!CHAIN_CONFIG.distributorAddress), this one must change
     // too. `stOlasDistributorAddress` is the same on-chain artifact threaded
-    // through `StatusGatherConfig`; do NOT substitute `tjinnDistributorAddress`
-    // (different contract on a different chain).
+    // through `StatusGatherConfig`.
     const evictionIntervalMs = status.config?.evictionCheckIntervalMs ?? 0;
     raw.evictionCheckIntervalMs = evictionIntervalMs;
     raw.autoRestakeEnabled =
@@ -933,6 +601,34 @@ export async function gatherGatheredStatusRaw(store, status) {
             };
         }
     }
+    // L1 (Ethereum Sepolia) master gas runway (#1296). Same master key as L2;
+    // balance read on the L1 chain. Testnet-only — mainnet has no L1 gas surface
+    // here. Error-safe: a failed L1 read sets `error`, it never throws the
+    // endpoint. The L1 daily estimate reuses the resolved `daily` (env
+    // JINN_MASTER_ETH_DAILY_WEI — no new config key); the L1 floor reuses the
+    // per-chain `minEoaGasEth`, the same EOA gas floor that sizes the L2 master
+    // gate above.
+    if (status.network === 'testnet' &&
+        fleet?.master_address) {
+        raw.l1MasterDailyEstimateWei = daily.toString();
+        raw.minL1MasterEthWei = chainCfg.minEoaGasEth.toString();
+        try {
+            const l1Client = createPublicClient({
+                chain: sepolia,
+                transport: http(TESTNET_ETHEREUM_RPC_URL),
+            });
+            const l1Bal = await l1Client.getBalance({
+                address: fleet.master_address,
+            });
+            raw.l1Master = { address: fleet.master_address, balanceWei: l1Bal.toString() };
+        }
+        catch (e) {
+            raw.l1Master = {
+                address: fleet.master_address,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
     if (fleet) {
         const per = {};
         for (const svc of fleet.services) {
@@ -949,11 +645,6 @@ export async function gatherGatheredStatusRaw(store, status) {
             raw.serviceBalanceErrors = bal.errorsByDisplay;
         }
     }
-    // The tJINN read started up front (overlapping the Base-RPC fan-out). It is
-    // awaited here, as late as possible — after ALL other awaited Base-chain work
-    // — so the up-to-4s tJINN timeout never serializes the Base fan-out behind it.
-    // `gatherTjinnStatus` is internally error-safe, so a plain await is safe.
-    raw.tJinn = await tJinnPromise;
     return raw;
 }
 export async function gatherStatusForApi(store, status) {
@@ -961,7 +652,7 @@ export async function gatherStatusForApi(store, status) {
     const body = assembleStatusV1(raw);
     // Loop-completion + impl-state commit cadence (#959). Both are read-only and
     // degrade to zeroes / an empty list — they never throw the status endpoint.
-    body.loopCompletion = gatherLoopCompletion(store);
+    body.loopCompletion = gatherLoopCompletion(store.taskRunReadModel());
     if (status?.engine?.implStateDirRoot) {
         body.implStateCadence = gatherImplStateCadence(status.engine.implStateDirRoot);
     }
@@ -1011,6 +702,13 @@ export async function gatherStatusForApi(store, status) {
                     // contributing row is harvested actual telemetry (issue #1004 AC4).
                     estimated: block.estimated || week.estimated,
                     paused,
+                    // active = this credential has spend in the current 7d window, so it
+                    // is the one actually being worked against (distinguishes a
+                    // configured-but-idle credential from the live one — issue #891).
+                    // Cold-start caveat: a working harness reads active=false until its
+                    // first cost row lands in the window (fresh node or just-reset 7d
+                    // window), so this can transiently under-report the live credential.
+                    active: week.usdMicros > 0,
                     blockResetsAt,
                     weekResetsAt,
                 };