@jinn-network/client 0.1.8 → 0.1.9-canary.01623b98

package/dist/api/gather-status.js

@@ -1,25 +1,25 @@
 /**
  * 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 { blockResetsAtUtc, weekResetsAtUtc } from '../spend/ai-units.js';
+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 { 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 = [
     {
@@ -30,81 +30,6 @@ 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();
 function readDaemonRuntime(earningDir) {
     if (!earningDir)
         return undefined;
@@ -124,24 +49,22 @@ function readDaemonRuntime(earningDir) {
         return { pidPath, pid, alive: false, stale: true };
     }
 }
-const predictionOperatorStatusCache = new WeakMap();
 /**
- * Module-scoped first-seen-evicted tracker for the suppression window (issue #651).
- *
- * Key: `${chain}:${serviceId}`. Value: epoch ms when this gatherer first
- * observed `getStakingState === 2` for the service. Cleared as soon as the
- * service is no longer reported evicted, so a successful auto-restake (or a
- * manual one) immediately resets the window.
- *
- * Lives at module scope intentionally: gather-status is invoked on every
- * status read and we need state to persist across reads. The daemon is
- * single-process; no cross-instance coordination required.
+ * 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).
  */
-const evictionFirstSeenMs = new Map();
-/** Test-only: clear the first-seen-evicted tracker. Do not call from production code. */
-export function __resetEvictionFirstSeenForTests() {
-    evictionFirstSeenMs.clear();
+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`.
  *
@@ -162,18 +85,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';
 }
@@ -296,159 +221,7 @@ 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;
-}
-async function sumPendingStakingRewards(rpcUrl, network, fleet) {
+export async function sumPendingStakingRewards(rpcUrl, network, fleet) {
     const targets = listStolasClaimTargets(fleet.services);
     if (targets.length === 0) {
         return { sum: '0', pendingByService: {} };
@@ -499,158 +272,6 @@ 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;
@@ -772,23 +393,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?.();
@@ -814,7 +455,7 @@ export async function gatherGatheredStatusRaw(store, status) {
     }
     let predictionV1;
     try {
-        predictionV1 = gatherPredictionV1Status(store, {
+        predictionV1 = gatherPredictionV1Status(taskRunReadModel, {
             operator: predictionOperator,
             operatorError: predictionOperatorError,
         });
@@ -829,6 +470,7 @@ export async function gatherGatheredStatusRaw(store, status) {
         shutdownState,
         daemonRuntime: readDaemonRuntime(status?.earningDir),
         daemonStartedAt,
+        passwordRotationAt: resolvePasswordRotationAt(status?.passwordRotation),
         dbPath: store.path,
         earningDir: status?.earningDir,
         activityCounts,
@@ -846,9 +488,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) {
@@ -864,11 +504,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,
@@ -902,8 +537,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 =
@@ -949,99 +583,6 @@ export async function gatherGatheredStatusRaw(store, status) {
             };
         }
     }
-    if (fleet && raw.rpc.ok) {
-        const pr = await sumPendingStakingRewards(status.rpcUrl, status.network, fleet);
-        if ('sum' in pr) {
-            raw.pendingStakingRewardsWei = pr.sum;
-            raw.pendingByService = pr.pendingByService;
-            if (pr.nextCheckpointAt)
-                raw.nextCheckpointAt = pr.nextCheckpointAt;
-        }
-        else {
-            raw.pendingRewardsError = pr.error;
-        }
-        // Eviction state + inactivity — best-effort; never blocks the rest of status assembly.
-        try {
-            const evictedByServiceIndex = {};
-            const inactivityByServiceIndex = {};
-            await Promise.all(fleet.services.map(async (svc) => {
-                const serviceId = svc.service_id;
-                const stakingProxy = svc.staking_address;
-                if (!serviceId || !stakingProxy)
-                    return;
-                const di = displayFleetServiceIndex(svc);
-                try {
-                    const [state, info] = await Promise.all([
-                        client.readContract({
-                            address: stakingProxy,
-                            abi: JINN_STAKING_ABI,
-                            functionName: 'getStakingState',
-                            args: [BigInt(serviceId)],
-                        }),
-                        client.readContract({
-                            address: stakingProxy,
-                            abi: JINN_STAKING_ABI,
-                            functionName: 'getServiceInfo',
-                            args: [BigInt(serviceId)],
-                        }).catch(() => null),
-                    ]);
-                    // getStakingState returns uint8; 2 = Evicted enum value
-                    evictedByServiceIndex[di] = Number(state) === 2;
-                    // getServiceInfo returns a struct — inactivity is seconds of accumulated inactivity
-                    if (info != null) {
-                        const inactivity = info.inactivity;
-                        if (typeof inactivity === 'bigint') {
-                            inactivityByServiceIndex[di] = Number(inactivity);
-                        }
-                    }
-                }
-                catch {
-                    // Transient RPC errors: skip silently; evicted defaults to false
-                }
-            }));
-            raw.evictedByServiceIndex = evictedByServiceIndex;
-            raw.inactivityByServiceIndex = inactivityByServiceIndex;
-            // First-seen tracker for the suppression window (issue #651).
-            // Key by `${chain}:${serviceId}` to survive multi-chain fleet layouts.
-            const nowMs = Date.now();
-            const chainKey = fleet.chain;
-            const evictedSinceByServiceIndex = {};
-            for (const svc of fleet.services) {
-                const di = displayFleetServiceIndex(svc);
-                const sid = svc.service_id;
-                if (sid == null)
-                    continue;
-                const key = `${chainKey}:${sid}`;
-                // Three-way: `true` → start/preserve window; `false` → clear it;
-                // `undefined` (read failed) → leave prior state untouched so a
-                // transient RPC flap does not reset the suppression window
-                // (issue #651 review Finding B).
-                if (evictedByServiceIndex[di] === true) {
-                    let firstSeen = evictionFirstSeenMs.get(key);
-                    if (firstSeen === undefined) {
-                        firstSeen = nowMs;
-                        evictionFirstSeenMs.set(key, firstSeen);
-                    }
-                    evictedSinceByServiceIndex[di] = new Date(firstSeen).toISOString();
-                }
-                else if (evictedByServiceIndex[di] === false) {
-                    evictionFirstSeenMs.delete(key);
-                }
-                else {
-                    // Read failed — preserve any prior `evictedSince` so the next
-                    // successful read does not bump the timestamp.
-                    const firstSeen = evictionFirstSeenMs.get(key);
-                    if (firstSeen !== undefined) {
-                        evictedSinceByServiceIndex[di] = new Date(firstSeen).toISOString();
-                    }
-                }
-            }
-            raw.evictedSinceByServiceIndex = evictedSinceByServiceIndex;
-        }
-        catch {
-            // Non-fatal: staking state reads should not prevent status from returning
-        }
-    }
     if (fleet) {
         const per = {};
         for (const svc of fleet.services) {
@@ -1058,16 +599,17 @@ 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) {
     const raw = await gatherGatheredStatusRaw(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.taskRunReadModel());
+    if (status?.engine?.implStateDirRoot) {
+        body.implStateCadence = gatherImplStateCadence(status.engine.implStateDirRoot);
+    }
     const caps = status?.spendCaps;
     if (caps && Object.keys(caps).length > 0) {
         const now = new Date();
@@ -1087,18 +629,40 @@ export async function gatherStatusForApi(store, status) {
         // Dedupe credentials across manifests — multiple SolverNets on the same
         // credential share one row.
         const uniqueCredentials = new Set(Object.values(aiUnitsCfg.manifestCredentials));
+        // Peg: usd_micros = units / 100 * GPT_5_4_MINI_USD_PER_BLOCK * 1e6.
+        // Inverse (USD micros -> units) for the legacy unit surface (#1006).
+        const usdMicrosToUnits = (usdMicros) => (usdMicros / 1_000_000 / GPT_5_4_MINI_USD_PER_BLOCK) * 100;
         body.aiUnits = {
             credentials: [...uniqueCredentials].map((credentialId) => {
-                const unitsThisBlock = store.aiUnitsThisBlock(credentialId, now);
-                const unitsThisWeek = store.aiUnitsThisWeek(credentialId, now);
-                const paused = unitsThisBlock >= aiUnitsCfg.capPerBlock || unitsThisWeek >= aiUnitsCfg.capPerWeek;
+                const block = store.usdMicrosThisBlock(credentialId, now);
+                const week = store.usdMicrosThisWeek(credentialId, now);
+                const paused = block.usdMicros >= aiUnitsCfg.capPerBlockUsdMicros ||
+                    week.usdMicros >= aiUnitsCfg.capPerWeekUsdMicros;
                 return {
                     credentialId,
-                    unitsThisBlock,
-                    unitsThisWeek,
+                    // #1006: legacy unit fields, derived from USD via the peg.
+                    unitsThisBlock: usdMicrosToUnits(block.usdMicros),
+                    unitsThisWeek: usdMicrosToUnits(week.usdMicros),
                     capPerBlock: aiUnitsCfg.capPerBlock,
                     capPerWeek: aiUnitsCfg.capPerWeek,
+                    // USD fields (issue #1004).
+                    usdMicrosThisBlock: block.usdMicros,
+                    usdMicrosThisWeek: week.usdMicros,
+                    capPerBlockUsdMicros: aiUnitsCfg.capPerBlockUsdMicros,
+                    capPerWeekUsdMicros: aiUnitsCfg.capPerWeekUsdMicros,
+                    // estimated = the summed figure includes any estimate-backed cost
+                    // (a telemetry-less/heuristic harness such as Hermes, or an
+                    // in-flight claimed row not yet harvested); false only when every
+                    // 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,
                 };