@fased/fased 0.1.62 → 0.1.64

package/extensions/sat-mining/index.ts

@@ -90,13 +90,16 @@ import {
   plannerPolicyVersion,
   scorePlannerOutcome,
 } from "./src/planner-policy.js";
+import { SAT_PROTOCOL_CONSTANTS } from "./src/protocol-contract.js";
 import { createSatRecoveryService } from "./src/recovery-service.js";
 import { readSatValidatorArtifact, recomputeSatValidatorArtifact } from "./src/replay.js";
 import { createSatRoundWatcherService } from "./src/round-watcher.js";
 import {
   invalidateSatReadCaches,
+  inspectSatCycle,
   inspectSatEpoch,
   inspectSatClaimReceipt,
+  inspectSatBondStakingDistributor,
   inspectCurrentSatRoundBucket,
   inspectSatMinerCapitalAccountStatus,
   inspectSatMinerCycleByAddress,
@@ -133,36 +136,44 @@ import {
   withSatServiceReadTimeout,
 } from "./src/service-read-timeout.js";
 import {
-  submitSatBootstrap,
   submitSatClaimProtocolDistributorSat,
   submitSatClaimProtocolTreasury,
+  submitSatClaimUnallocatedStakingRewards,
   submitSatClaimCycleRewards,
   submitSatClaimCycleRewardsBatch,
+  submitSatAbortEmptyCycle,
   submitSatCompactPendingCycleRange,
   submitSatCloseResolvedCycleArtifacts,
   submitSatCloseResolvedCleanupBatch,
   submitSatCloseResolvedCycleRegistryPage,
   submitSatCloseResolvedMinerCycleState,
-  submitSatCycle,
+  submitSatCloseCommitPhase,
+  submitSatCommitCycle,
   submitSatDepositMinerCapital,
   submitSatFinalizeCycleSettlement,
   submitSatInitMinerCapital,
   submitSatOpenCycle,
   submitSatOpenDispute,
+  submitSatReleaseUnrevealedCommit,
   submitSatRepublishEpochRoots,
+  submitSatRevealCycle,
   submitSatRefillRegistryReserveFromTreasury,
   submitSatScoreCyclePage,
   submitSatSetActiveCommit,
-  submitSatSetProtocolRecipients,
+  submitSatSealCycleEntropy,
+  submitSatTopUpRegistryReserve,
   submitSatRetargetUnlock,
   submitSatResolveDispute,
   submitSatDistributeCyclePage,
   submitSatSettleCyclePage,
+  submitSatSyncBondStakingRewards,
   submitSatWithdrawMinerCapital,
   resolveSatValidatorAuthority,
   submitSatValidatorAttestation,
+  runWithSatSubmissionWorkflow,
 } from "./src/solana-submit.js";
 import { computeMiningStrategy } from "./src/strategy-engine.js";
+import { digestSatSubmissionIntent } from "./src/submission-ledger.js";
 import {
   buildSatValidatorArtifact,
   findSatValidatorArtifact,
@@ -492,8 +503,7 @@ function resolveWalletSolanaRpcUrl(env: NodeJS.ProcessEnv, walletId?: string): s
   const perWalletKey = suffix ? `FASED_WALLET_SOLANA_RPC_URL__${suffix}` : "";
   const value =
     (perWalletKey ? String(env[perWalletKey] ?? "").trim() : "") ||
-    String(env.FASED_WALLET_SOLANA_RPC_URL ?? "").trim() ||
-    String(env.FASED_WALLET_EMBEDDED_KEYSTORE_RPC_URL ?? "").trim();
+    String(env.FASED_WALLET_SOLANA_RPC_URL ?? "").trim();
   return value || undefined;
 }
 
@@ -1200,9 +1210,9 @@ const satMiningPlugin = {
       disputes:
         "usage: /satdisputesonchain <validator-authority> <epoch-id> <round-id> [reasonCode=..] [requireNonzeroSlashPenalty=true] [sortBy=targetAuthority|reasonCode|slashPenaltyOwed|openedAt] [sortOrder=asc|desc]",
       resolve:
-        "usage: /satresolvedispute <dispute-authority> <target-authority> <epoch-id> <round-id> <dismissed|upheld>",
+        "usage: /satresolvedispute <dispute-authority> <target-authority> <epoch-id> <round-id> <dismissed|upheld> [idempotencyKey=<key>]",
       republish:
-        "usage: /satrepublishroots <epoch-id> <bucket-root> <score-root> <coordination-root>  # returns preflight rejection reasons instead of submitting when invalid",
+        "usage: /satrepublishroots <epoch-id> <bucket-root> <score-root> <coordination-root> [idempotencyKey=<key>]  # returns preflight rejection reasons instead of submitting when invalid",
       recovery: "usage: /satrecoverysummary <validator-authority> <epoch-id> <round-id>",
     };
     const satUsageWithCheatsheet = (usage: string) =>
@@ -1435,11 +1445,14 @@ const satMiningPlugin = {
       description: "Resolve a SAT dispute as dismissed or upheld.",
       acceptsArgs: true,
       handler: async (ctx) => {
-        const [disputeAuthority, targetAuthority, epochRaw, microRoundRaw, statusRaw] = (
-          ctx.args ?? ""
-        )
-          .split(/\s+/)
-          .filter(Boolean);
+        const [
+          disputeAuthority,
+          targetAuthority,
+          epochRaw,
+          microRoundRaw,
+          statusRaw,
+          ...optionParts
+        ] = (ctx.args ?? "").split(/\s+/).filter(Boolean);
         if (!disputeAuthority || !targetAuthority || !epochRaw || !microRoundRaw || !statusRaw) {
           return { text: satUsageWithCheatsheet(satUsageText.resolve) };
         }
@@ -1449,6 +1462,13 @@ const satMiningPlugin = {
         if (!Number.isFinite(statusFlag)) {
           return { text: satUsageWithCheatsheet(satUsageText.resolve) };
         }
+        const idempotencyMatch =
+          optionParts.length === 1
+            ? optionParts[0]?.match(/^idempotency(?:Key|-key)=(.+)$/u)
+            : null;
+        if (optionParts.length > 0 && !idempotencyMatch) {
+          return { text: satUsageWithCheatsheet(satUsageText.resolve) };
+        }
         const request = state.client.buildResolveDisputeRequest({
           disputeAuthority,
           targetAuthority,
@@ -1456,7 +1476,10 @@ const satMiningPlugin = {
           microRoundId: Number(microRoundRaw),
           statusFlag,
         });
-        const submitted = await submitSatResolveDispute(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `command:satresolvedispute:${idempotencyMatch?.[1] ?? digestSatSubmissionIntent(request.params)}`,
+          async () => await submitSatResolveDispute(state.activeConfig, request.params),
+        );
         return { text: JSON.stringify({ request, submitted }, null, 2) };
       },
     });
@@ -1465,12 +1488,19 @@ const satMiningPlugin = {
       description: "Republish corrected SAT epoch roots after upheld dispute review.",
       acceptsArgs: true,
       handler: async (ctx) => {
-        const [epochRaw, bucketRoot, scoreRoot, coordinationRoot] = (ctx.args ?? "")
+        const [epochRaw, bucketRoot, scoreRoot, coordinationRoot, ...optionParts] = (ctx.args ?? "")
           .split(/\s+/)
           .filter(Boolean);
         if (!epochRaw || !bucketRoot || !scoreRoot || !coordinationRoot) {
           return { text: satUsageWithCheatsheet(satUsageText.republish) };
         }
+        const idempotencyMatch =
+          optionParts.length === 1
+            ? optionParts[0]?.match(/^idempotency(?:Key|-key)=(.+)$/u)
+            : null;
+        if (optionParts.length > 0 && !idempotencyMatch) {
+          return { text: satUsageWithCheatsheet(satUsageText.republish) };
+        }
         const request = state.client.buildRepublishEpochRootsRequest({
           epochId: Number(epochRaw),
           bucketRoot,
@@ -1484,7 +1514,10 @@ const satMiningPlugin = {
         if (!preflight.canRepublish) {
           return { text: JSON.stringify({ request, preflight }, null, 2) };
         }
-        const submitted = await submitSatRepublishEpochRoots(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `command:satrepublishroots:${idempotencyMatch?.[1] ?? digestSatSubmissionIntent(request.params)}`,
+          async () => await submitSatRepublishEpochRoots(state.activeConfig, request.params),
+        );
         return { text: JSON.stringify({ request, preflight, submitted }, null, 2) };
       },
     });
@@ -1905,7 +1938,10 @@ const satMiningPlugin = {
       parameters: SatResolveDisputeToolSchema,
       async execute(_toolCallId, params) {
         const request = state.client.buildResolveDisputeRequest(params);
-        const submitted = await submitSatResolveDispute(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `tool:sat_resolve_dispute:${_toolCallId}`,
+          async () => await submitSatResolveDispute(state.activeConfig, request.params),
+        );
         return {
           content: [
             { type: "text" as const, text: JSON.stringify({ request, submitted }, null, 2) },
@@ -1933,7 +1969,10 @@ const satMiningPlugin = {
             details: { request, preflight },
           };
         }
-        const submitted = await submitSatRepublishEpochRoots(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `tool:sat_republish_epoch_roots:${_toolCallId}`,
+          async () => await submitSatRepublishEpochRoots(state.activeConfig, request.params),
+        );
         return {
           content: [
             {
@@ -1952,7 +1991,10 @@ const satMiningPlugin = {
       parameters: SatValidatorToolSchema,
       async execute(_toolCallId, params) {
         const request = state.client.buildSubmitValidatorAttestationRequest(params);
-        const submitted = await submitSatValidatorAttestation(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `tool:sat_submit_validator_attestation:${_toolCallId}`,
+          async () => await submitSatValidatorAttestation(state.activeConfig, request.params),
+        );
         const response = await buildValidatorSubmissionSummary({
           epochId: request.params.epochId,
           microRoundId: request.params.microRoundId,
@@ -1973,7 +2015,10 @@ const satMiningPlugin = {
       parameters: SatDisputeToolSchema,
       async execute(_toolCallId, params) {
         const request = state.client.buildOpenDisputeRequest(params);
-        const submitted = await submitSatOpenDispute(state.activeConfig, request.params);
+        const submitted = await runWithSatSubmissionWorkflow(
+          `tool:sat_open_dispute:${_toolCallId}`,
+          async () => await submitSatOpenDispute(state.activeConfig, request.params),
+        );
         const response = await buildValidatorSubmissionSummary({
           epochId: request.params.epochId,
           microRoundId: request.params.microRoundId,
@@ -2037,7 +2082,7 @@ const satMiningPlugin = {
         "depositMinerCapital",
         "withdrawMinerCapital",
         "setActiveCommit",
-        "bootstrapRegistryReserve",
+        "topUpRegistryReserve",
         "openCycle",
         "submitCycle",
         "claimCycleRewards",
@@ -2051,6 +2096,7 @@ const satMiningPlugin = {
     const isInternalSatMaintenanceAction = (action: string | null | undefined) =>
       new Set([
         "bootstrapRegistryReserve",
+        "topUpRegistryReserve",
         "openCycle",
         "setActiveCommit",
         "closeResolvedMinerCycleState",
@@ -2928,6 +2974,7 @@ const satMiningPlugin = {
       cycleId?: number | null;
       txHash: string | null;
       status: "success" | "failure";
+      complete?: boolean;
       message?: string | null;
     }) => {
       mergeRecentActionTail([
@@ -2986,6 +3033,34 @@ const satMiningPlugin = {
       );
       void persistRecentActions();
     };
+    const markClaimActionResult = (params: {
+      action: "claimCycleRewards" | "claimCycleRewardsBatch";
+      txHash: string | null | undefined;
+      cycleIds: readonly number[];
+      resolvedCycleIds: readonly number[];
+    }) => {
+      invalidateMiningReadCaches();
+      state.lastAction = params.action;
+      state.lastActionTxHash = params.txHash ?? null;
+      state.lastFailure = null;
+      const resolved = new Set(params.resolvedCycleIds);
+      const actionAt = new Date().toISOString();
+      mergeRecentActionTail(
+        [...new Set(params.cycleIds)]
+          .filter((cycleId) => Number.isFinite(cycleId) && cycleId >= 0)
+          .map((cycleId) => ({
+            action: params.action,
+            cycleId,
+            txHash: params.txHash ?? null,
+            status: "success" as const,
+            complete: resolved.has(cycleId),
+            message: resolved.has(cycleId)
+              ? "Cycle rewards fully claimed."
+              : "Bounded SAT claim chunk submitted; rewards remain claimable.",
+            at: actionAt,
+          })),
+      );
+    };
     const markActionFailure = (action: string, error: unknown, cycleId?: number | null) => {
       const message = sanitizeMiningActionMessage(error);
       state.lastAction = action;
@@ -3121,19 +3196,61 @@ const satMiningPlugin = {
         const claimableRebate =
           BigInt(minerCycle.claimableDetRebateLamports ?? "0") +
           BigInt(minerCycle.claimablePerfRebateLamports ?? "0");
-        const claimedSat = BigInt(minerCycle.claimedSatRaw ?? "0");
-        const claimedRebate =
-          BigInt(minerCycle.claimedDetRebateLamports ?? "0") +
-          BigInt(minerCycle.claimedPerfRebateLamports ?? "0");
-        if (
-          minerCycle.capitalLockReleased &&
-          (claimedSat > 0n || claimedRebate > 0n || (claimableSat === 0n && claimableRebate === 0n))
-        ) {
+        if (minerCycle.capitalLockReleased && claimableSat === 0n && claimableRebate === 0n) {
           resolved.push(cycleId);
         }
       }
       return resolved;
     };
+    const resolveClaimCompletion = async (cycleIds: readonly number[]) => {
+      const authority = state.activeWalletAddress;
+      if (!authority) {
+        throw new Error("Mining wallet authority is unavailable after claim confirmation.");
+      }
+      invalidateMiningReadCaches();
+      const resolvedCycleIds: number[] = [];
+      const pendingCycleIds: number[] = [];
+      for (const cycleId of [...new Set(cycleIds)]) {
+        const minerCycle = await satOps
+          .inspectSatMinerCycle(state.activeConfig, { authority, cycleId })
+          .catch(() => null);
+        const claimableSat = BigInt(minerCycle?.claimableSatRaw ?? "0");
+        const claimableRebate =
+          BigInt(minerCycle?.claimableDetRebateLamports ?? "0") +
+          BigInt(minerCycle?.claimablePerfRebateLamports ?? "0");
+        if (
+          minerCycle?.capitalLockReleased === true &&
+          claimableSat === 0n &&
+          claimableRebate === 0n
+        ) {
+          resolvedCycleIds.push(cycleId);
+        } else {
+          pendingCycleIds.push(cycleId);
+        }
+      }
+      return { resolvedCycleIds, pendingCycleIds };
+    };
+    const applyClaimCompletion = (params: {
+      action: "claimCycleRewards" | "claimCycleRewardsBatch";
+      txHash: string | null | undefined;
+      cycleIds: readonly number[];
+      resolvedCycleIds: readonly number[];
+      pendingCycleIds: readonly number[];
+    }) => {
+      for (const cycleId of params.resolvedCycleIds) {
+        getOrCreateRoundExecutionState(state, cycleId, 0).claimSubmitted = true;
+      }
+      for (const cycleId of params.pendingCycleIds) {
+        getOrCreateRoundExecutionState(state, cycleId, 0).claimSubmitted = false;
+      }
+      markSatClaimBacklogClaimed(state, params.resolvedCycleIds, params.txHash);
+      markSatClaimBacklogReady(
+        state,
+        params.pendingCycleIds,
+        "bounded SAT claim chunk submitted; rewards remain claimable",
+      );
+      markClaimActionResult(params);
+    };
     const capturePendingPlannerCycle = async (cycleId: number): Promise<void> => {
       const plannerSnapshot =
         state.lastPlannerDecision?.cycleId === cycleId ? state.lastPlannerDecision.snapshot : null;
@@ -3234,7 +3351,10 @@ const satMiningPlugin = {
         }
       }
       for (const execution of state.roundExecution.values()) {
-        if (execution.participationSubmitted && !execution.claimSubmitted) {
+        if (
+          (execution.commitSubmitted || execution.participationSubmitted) &&
+          !execution.claimSubmitted
+        ) {
           return true;
         }
       }
@@ -3242,7 +3362,12 @@ const satMiningPlugin = {
         if (entry.status !== "success" || typeof entry.cycleId !== "number" || entry.cycleId <= 0) {
           return false;
         }
-        if (entry.action !== "openCycle" && entry.action !== "submitCycle") {
+        if (
+          entry.action !== "openCycle" &&
+          entry.action !== "submitCycle" &&
+          entry.action !== "commitCycle" &&
+          entry.action !== "revealCycle"
+        ) {
           return false;
         }
         return !hasSuccessfulClaimOrCloseRecentAction(entry.cycleId);
@@ -3288,6 +3413,7 @@ const satMiningPlugin = {
         strategyExecution:
           state.activeConfig.strategyExecution ??
           strategyModeToExecution(state.activeConfig.strategyMode),
+        cycleCadence: state.activeConfig.cycleCadence ?? 1,
         claimMode: "auto",
         payout: state.activeConfig.payout ?? true,
         strategyMode: state.activeConfig.strategyMode ?? "base",
@@ -3392,6 +3518,10 @@ const satMiningPlugin = {
       state.activeConfig.strategyExecution = strategyModeToExecution(
         state.activeConfig.strategyMode,
       );
+      state.activeConfig.cycleCadence =
+        profile.cycleCadence === 2 || profile.cycleCadence === 6 || profile.cycleCadence === 12
+          ? profile.cycleCadence
+          : 1;
       state.activeConfig.claimMode = "auto";
       state.activeConfig.payout =
         typeof profile.payout === "boolean" ? profile.payout : state.activeConfig.payout;
@@ -3641,8 +3771,7 @@ const satMiningPlugin = {
       const perWalletKey = suffix ? `FASED_WALLET_SOLANA_RPC_URL__${suffix.toUpperCase()}` : "";
       return Boolean(
         (perWalletKey ? String(effectiveEnv[perWalletKey] ?? "").trim() : "") ||
-        String(effectiveEnv.FASED_WALLET_SOLANA_RPC_URL ?? "").trim() ||
-        String(effectiveEnv.FASED_WALLET_EMBEDDED_KEYSTORE_RPC_URL ?? "").trim(),
+        String(effectiveEnv.FASED_WALLET_SOLANA_RPC_URL ?? "").trim(),
       );
     };
     const normalizeAddressValue = (value?: string) => {
@@ -4182,7 +4311,7 @@ const satMiningPlugin = {
           remediation:
             wallet?.signerCapability === "background-ready"
               ? undefined
-              : "Use the built-in local signer or embedded keystore for unattended mining automation.",
+              : "Use the local native signer for unattended Mining. Wallet Standard and Turnkey are reviewed/manual wallet paths, not background Mining signers.",
         },
         {
           key: "rpcReady",
@@ -4235,13 +4364,13 @@ const satMiningPlugin = {
               ? "SAT miner capital account has an invalid owner"
               : "Fund Mining capital first"
             : capitalFreeLamports >= capitalEntryThreshold
-              ? "Meets 0.25 SOL funded minimum entry"
-              : "Below 0.25 SOL funded minimum entry",
+              ? "Meets 0.25 SOL minimum eligibility capital"
+              : "Below 0.25 SOL minimum eligibility capital",
           remediation: !minerCapitalInitialized
             ? minerCapitalRemediation
             : capitalFreeLamports >= capitalEntryThreshold
               ? undefined
-              : "Deposit at least 0.25 SOL into miner capital to participate in SAT cycles.",
+              : "Deposit at least 0.25 SOL plus reveal collateral into miner capital to participate in SAT cycles.",
         },
         {
           key: "ataReady",
@@ -4471,7 +4600,9 @@ const satMiningPlugin = {
           return undefined;
         }
       })();
-      const totalCommittedLamports = currentExecution?.participationSubmitted ? 250_000_000 : 0;
+      const totalCommittedLamports = currentExecution?.commitSubmitted
+        ? (currentExecution.commitLamports ?? 250_000_000)
+        : 0;
       const unlockRatio = Math.min(1, totalCommittedLamports / currentUnlockTargetLamports);
       const claimableSatRaw = snapshot.walletEpoch
         ? (
@@ -4481,7 +4612,11 @@ const satMiningPlugin = {
         : undefined;
       const slashPenaltyOwed = BigInt(snapshot.stake?.slashPenaltyOwed ?? "0");
       const hasClaimableSat = claimableSatRaw ? BigInt(claimableSatRaw) > 0n : false;
-      const lastParticipation = latestRecentAction("submitCycle");
+      const lastParticipation = latestRecentActionAny([
+        "revealCycle",
+        "commitCycle",
+        "submitCycle",
+      ]);
       const lastMiningCrank =
         latestRecentAction("distributeCyclePage") ??
         latestRecentAction("scoreCyclePage") ??
@@ -4620,6 +4755,8 @@ const satMiningPlugin = {
         (action) =>
           action.status === "success" &&
           (action.action === "submitCycle" ||
+            action.action === "commitCycle" ||
+            action.action === "revealCycle" ||
             action.action === "setActiveCommit" ||
             action.action === "depositCapital" ||
             action.action === "withdrawCapital" ||
@@ -4636,6 +4773,8 @@ const satMiningPlugin = {
         (state.running ||
           state.activeConfig.enabled ||
           state.activeConfig.drainOnly ||
+          currentExecution?.commitSubmitted ||
+          previousExecution?.commitSubmitted ||
           currentExecution?.participationSubmitted ||
           previousExecution?.participationSubmitted ||
           hasPositiveLamportsValue(cachedStatus?.currentCapitalFundedLamports) ||
@@ -4654,6 +4793,39 @@ const satMiningPlugin = {
         globalState?.minimumEntryLamports ??
         "250000000";
       const cycleErosionPpm = resolveSatEffectiveCycleErosionPpm(globalState);
+      const cycleCadence = state.activeConfig.cycleCadence ?? 1;
+      const runway = (() => {
+        try {
+          const funded = BigInt(currentCapitalFundedLamports);
+          const commit = BigInt(activeCommitLamports);
+          const erosion = (commit * cycleErosionPpm) / 1_000_000n;
+          const missedRevealPenalty =
+            (commit * BigInt(SAT_PROTOCOL_CONSTANTS.cycleNonRevealPenaltyBps)) / 10_000n;
+          const collateral = missedRevealPenalty > erosion ? missedRevealPenalty : erosion;
+          const requiredToEnter = commit + collateral;
+          const participations =
+            funded < requiredToEnter
+              ? 0n
+              : erosion === 0n
+                ? null
+                : (funded - requiredToEnter) / erosion + 1n;
+          const calendarCycles =
+            participations == null ? null : participations * BigInt(cycleCadence);
+          const days =
+            calendarCycles == null
+              ? null
+              : Number(calendarCycles * BigInt(SAT_CYCLE_SECONDS)) / 86_400;
+          return {
+            commitCollateralLamports: collateral.toString(),
+            estimatedParticipations: participations?.toString() ?? null,
+            estimatedCalendarCycles: calendarCycles?.toString() ?? null,
+            estimatedDays: days,
+            excludesNetworkFees: true,
+          };
+        } catch {
+          return null;
+        }
+      })();
       const liveCycleErosionLamports = (() => {
         try {
           return ((BigInt(liveCycleCommittedLamports) * cycleErosionPpm) / 1_000_000n).toString();
@@ -4776,7 +4948,7 @@ const satMiningPlugin = {
       const liveCycleTotalCommittedLamports =
         currentCycleState?.totalCommittedLamports ??
         currentMinerCycleState?.committedLamports ??
-        (currentExecution?.participationSubmitted ? liveCycleCommittedLamports : null);
+        (currentExecution?.commitSubmitted ? liveCycleCommittedLamports : null);
       const liveCycleUnlockTargetLamports =
         currentCycleState?.unlockTargetLamports ?? globalState?.currentUnlockSolLamports ?? null;
       const liveCycleUnlockRatioFp =
@@ -4830,10 +5002,10 @@ const satMiningPlugin = {
       const latestSettledCycleId = settledHistory[0]?.cycleId ?? null;
       const latestSubmittedCycleId = (() => {
         const cycleIds = new Set<number>();
-        if (currentExecution?.participationSubmitted) {
+        if (currentExecution?.commitSubmitted || currentExecution?.participationSubmitted) {
           cycleIds.add(currentCycleId);
         }
-        if (previousExecution?.participationSubmitted) {
+        if (previousExecution?.commitSubmitted || previousExecution?.participationSubmitted) {
           cycleIds.add(previousCycleId);
         }
         for (const pendingCycleId of pendingCycleIds) {
@@ -4842,7 +5014,9 @@ const satMiningPlugin = {
         for (const entry of allUserFacingRecentActions) {
           if (
             entry.status === "success" &&
-            entry.action === "submitCycle" &&
+            (entry.action === "submitCycle" ||
+              entry.action === "commitCycle" ||
+              entry.action === "revealCycle") &&
             typeof entry.cycleId === "number" &&
             Number.isFinite(entry.cycleId)
           ) {
@@ -5092,6 +5266,8 @@ const satMiningPlugin = {
         strategyExecution:
           state.activeConfig.strategyExecution ??
           strategyModeToExecution(state.activeConfig.strategyMode),
+        cycleCadence,
+        runway,
         strategyMode: state.activeConfig.strategyMode ?? "base",
         network: state.activeConfig.network,
         riskMode: state.activeConfig.riskMode,
@@ -6661,7 +6837,30 @@ const satMiningPlugin = {
       return generated;
     };
 
-    api.registerGatewayMethod("sat.openCycle", async ({ params, respond }) => {
+    type SatGatewayHandler = Parameters<typeof api.registerGatewayMethod>[1];
+    const registerSatSubmissionMethod = (method: string, handler: SatGatewayHandler) => {
+      api.registerGatewayMethod(method, async (context) => {
+        const source =
+          context.params && typeof context.params === "object" && !Array.isArray(context.params)
+            ? (context.params as Record<string, unknown>)
+            : {};
+        const { idempotencyKey: rawIdempotencyKey, ...intentParams } = source;
+        const idempotencyKey =
+          typeof rawIdempotencyKey === "string" && rawIdempotencyKey.trim()
+            ? rawIdempotencyKey.trim()
+            : `derived:${digestSatSubmissionIntent(intentParams)}`;
+        try {
+          await runWithSatSubmissionWorkflow(
+            `gateway:${method}:${idempotencyKey}`,
+            async () => await handler(context),
+          );
+        } catch (error) {
+          respondGatewayError(context.respond, error);
+        }
+      });
+    };
+
+    registerSatSubmissionMethod("sat.openCycle", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const request = state.client.buildOpenCycleRequest({ cycleId });
@@ -6679,51 +6878,23 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.bootstrapRegistryReserve", async ({ params, respond }) => {
-      try {
-        const authority =
-          typeof (params as { authority?: string })?.authority === "string"
-            ? String((params as { authority?: string }).authority).trim()
-            : (state.activeWalletAddress ?? "");
-        const initialStake =
-          typeof (params as { initialStake?: number })?.initialStake === "number"
-            ? Number((params as { initialStake?: number }).initialStake)
-            : 0;
-        const submitted = await submitSatBootstrap(state.activeConfig, {
-          authority,
-          initialStake,
-        });
-        markActionSuccess("bootstrapRegistryReserve", submitted.txHash, null);
-        respond(true, jsonOk({ submitted, status: await getMiningStatus() }));
-      } catch (error) {
-        markActionFailure("bootstrapRegistryReserve", error, null);
-        respondGatewayError(respond, error);
-      }
-    });
-
-    api.registerGatewayMethod("sat.setProtocolRecipients", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.topUpRegistryReserve", async ({ params, respond }) => {
       try {
-        const treasuryRecipient =
-          typeof (params as { treasuryRecipient?: string })?.treasuryRecipient === "string"
-            ? String((params as { treasuryRecipient?: string }).treasuryRecipient).trim()
-            : "";
-        const distributorRecipient =
-          typeof (params as { distributorRecipient?: string })?.distributorRecipient === "string"
-            ? String((params as { distributorRecipient?: string }).distributorRecipient).trim()
-            : "";
-        const submitted = await submitSatSetProtocolRecipients(state.activeConfig, {
-          treasuryRecipient,
-          distributorRecipient,
+        const targetBalanceLamports = Number(
+          (params as { targetBalanceLamports?: number })?.targetBalanceLamports ?? 0,
+        );
+        const submitted = await submitSatTopUpRegistryReserve(state.activeConfig, {
+          targetBalanceLamports,
         });
-        markActionSuccess("setProtocolRecipients", submitted.txHash, null);
+        markActionSuccess("topUpRegistryReserve", submitted.txHash, null);
         respond(true, jsonOk({ submitted, status: await getMiningStatus() }));
       } catch (error) {
-        markActionFailure("setProtocolRecipients", error, null);
+        markActionFailure("topUpRegistryReserve", error, null);
         respondGatewayError(respond, error);
       }
     });
 
-    api.registerGatewayMethod("sat.claimProtocolTreasury", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.claimProtocolTreasury", async ({ params, respond }) => {
       try {
         const recipientOwner =
           typeof (params as { recipientOwner?: string })?.recipientOwner === "string"
@@ -6740,7 +6911,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.claimProtocolDistributorSat", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.claimProtocolDistributorSat", async ({ params, respond }) => {
       try {
         const recipientOwner =
           typeof (params as { recipientOwner?: string })?.recipientOwner === "string"
@@ -6757,7 +6928,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod(
+    registerSatSubmissionMethod(
       "sat.refillRegistryReserveFromTreasury",
       async ({ params, respond }) => {
         try {
@@ -6815,7 +6986,7 @@ const satMiningPlugin = {
         .slice(0, Math.max(0, Math.min(limit, SAT_MAINTENANCE_RECENT_CLEANUP_CYCLE_LIMIT)));
     };
 
-    api.registerGatewayMethod("sat.runProtocolMaintenanceOnce", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.runProtocolMaintenanceOnce", async ({ params, respond }) => {
       const submitted: Array<{
         lane: SatMaintenanceLane;
         action: string;
@@ -6891,18 +7062,20 @@ const satMiningPlugin = {
       };
       const readFresh = async () => {
         invalidateSatReadCaches();
-        const [global, treasuryState, registryReserve, rent] = await Promise.all([
-          satOps.inspectSatGlobalState(state.activeConfig).catch(() => null),
-          satOps.inspectSatTreasuryState(state.activeConfig).catch(() => null),
-          satOps.inspectSatRegistryReserveLamports(state.activeConfig).catch(() => null),
-          satOps.inspectSatRentExemptionLamports(state.activeConfig).catch(() => null),
-        ]);
+        const [global, treasuryState, registryReserve, rent, stakingDistributor] =
+          await Promise.all([
+            satOps.inspectSatGlobalState(state.activeConfig).catch(() => null),
+            satOps.inspectSatTreasuryState(state.activeConfig).catch(() => null),
+            satOps.inspectSatRegistryReserveLamports(state.activeConfig).catch(() => null),
+            satOps.inspectSatRentExemptionLamports(state.activeConfig).catch(() => null),
+            inspectSatBondStakingDistributor(state.activeConfig).catch(() => null),
+          ]);
         const target =
           targetBalanceLamports !== undefined
             ? BigInt(targetBalanceLamports)
             : BigInt(rent?.registryReserveTargetLamports ?? "200000000");
         const reserve = BigInt(registryReserve?.lamports ?? "0");
-        return { global, treasuryState, registryReserve, target, reserve };
+        return { global, treasuryState, registryReserve, stakingDistributor, target, reserve };
       };
       const buildLaneSummary = () => {
         const lanes: Record<
@@ -6955,6 +7128,7 @@ const satMiningPlugin = {
           pendingTreasurySatRaw: snapshot.treasuryState?.pendingTreasurySatRaw ?? "0",
           pendingTreasurySolLamports: snapshot.treasuryState?.pendingTreasurySolLamports ?? "0",
           pendingDistributorSatRaw: snapshot.treasuryState?.pendingDistributorSatRaw ?? "0",
+          unallocatedStakingRewardRaw: snapshot.stakingDistributor?.unallocatedRewardRaw ?? "0",
           cleanup: cleanupSummary,
           lanes: buildLaneSummary(),
           updatedAt: new Date().toISOString(),
@@ -7029,6 +7203,60 @@ const satMiningPlugin = {
           });
         }
 
+        // Protocol rewards are recorded atomically by the mining claim CPI.
+        // Any remaining vault delta is an unsolicited transfer and must be
+        // quarantined for the fixed treasury, never allocated to stakers.
+        const stakingRewardVaultRaw = BigInt(
+          snapshot.stakingDistributor?.rewardVaultBalanceRaw ?? "0",
+        );
+        const observedStakingRewardRaw = BigInt(
+          snapshot.stakingDistributor?.observedRewardVaultRaw ?? "0",
+        );
+        if (
+          snapshot.stakingDistributor?.statusLabel === "active" &&
+          stakingRewardVaultRaw > observedStakingRewardRaw &&
+          stakingRewardVaultRaw - observedStakingRewardRaw >= minSatRaw
+        ) {
+          const tx = await submitSatSyncBondStakingRewards(state.activeConfig);
+          pushSubmitted({
+            lane: "distributor",
+            action: "syncBondStakingRewards",
+            txHash: tx.txHash,
+          });
+          markActionSuccess("syncBondStakingRewards", tx.txHash, null);
+          snapshot = await readFresh();
+        } else {
+          pushSubmitted({
+            lane: "distributor",
+            action: "syncBondStakingRewards",
+            skipped: "no-unexpected-vault-balance-or-below-threshold",
+          });
+        }
+
+        const unallocatedTreasuryRecipient = snapshot.global?.treasuryRecipient;
+        if (
+          unallocatedTreasuryRecipient &&
+          unallocatedTreasuryRecipient !== defaultPubkey &&
+          BigInt(snapshot.stakingDistributor?.unallocatedRewardRaw ?? "0") >= minSatRaw
+        ) {
+          const tx = await submitSatClaimUnallocatedStakingRewards(state.activeConfig, {
+            recipientOwner: unallocatedTreasuryRecipient,
+          });
+          pushSubmitted({
+            lane: "treasury",
+            action: "claimUnallocatedStakingRewards",
+            txHash: tx.txHash,
+          });
+          markActionSuccess("claimUnallocatedStakingRewards", tx.txHash, null);
+          snapshot = await readFresh();
+        } else {
+          pushSubmitted({
+            lane: "treasury",
+            action: "claimUnallocatedStakingRewards",
+            skipped: "no-recipient-or-below-threshold",
+          });
+        }
+
         if (cleanupMaxCycles > 0 && cleanupBudgetMs > 0 && cleanupMaxTransactions > 0) {
           const maxCleanupCandidates = Math.min(
             50,
@@ -7180,7 +7408,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.initMinerCapital", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.initMinerCapital", async ({ params, respond }) => {
       try {
         await ensureSatCapitalActionSignerReady();
         const authority =
@@ -7196,7 +7424,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.depositMinerCapital", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.depositMinerCapital", async ({ params, respond }) => {
       try {
         await ensureSatCapitalActionSignerReady();
         const lamports = Number((params as { lamports?: number })?.lamports ?? 0);
@@ -7213,7 +7441,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.withdrawMinerCapital", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.withdrawMinerCapital", async ({ params, respond }) => {
       try {
         await ensureSatCapitalActionSignerReady();
         const lamports = Number((params as { lamports?: number })?.lamports ?? 0);
@@ -7228,7 +7456,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.setActiveCommit", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.setActiveCommit", async ({ params, respond }) => {
       try {
         await ensureSatCapitalActionSignerReady();
         const lamports = Number((params as { lamports?: number })?.lamports ?? 0);
@@ -7253,38 +7481,147 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.submitCycle", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.commitCycle", async ({ params, respond }) => {
+      const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
+      try {
+        const commitmentHex = String(
+          (params as { commitmentHex?: string })?.commitmentHex ?? "",
+        ).trim();
+        if (!/^[0-9a-f]{64}$/i.test(commitmentHex)) {
+          throw new Error("cycle commitment must be a 32-byte hexadecimal digest");
+        }
+        const submitted = await submitSatCommitCycle(state.activeConfig, {
+          cycleId,
+          commitmentHex,
+        });
+        if (Number.isFinite(cycleId) && cycleId >= 0) {
+          const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
+          execution.openRoundSubmitted = true;
+          execution.commitSubmitted = true;
+          execution.commitmentHex = commitmentHex.toLowerCase();
+        }
+        markActionSuccess("commitCycle", submitted.txHash, cycleId);
+        await persistRecentActions();
+        respond(true, jsonOk({ submitted }));
+      } catch (error) {
+        if (!isCycleMismatchError(error)) {
+          markActionFailure("commitCycle", error, cycleId);
+        }
+        respondGatewayError(respond, error);
+      }
+    });
+
+    registerSatSubmissionMethod("sat.closeCommitPhase", async ({ params, respond }) => {
+      const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
+      try {
+        const submitted = await submitSatCloseCommitPhase(state.activeConfig, { cycleId });
+        invalidateMiningReadCaches();
+        getOrCreateRoundExecutionState(state, cycleId, 0).entropyTargetPinned = true;
+        markActionSuccess("closeCommitPhase", submitted.txHash, cycleId);
+        await persistRecentActions();
+        respond(true, jsonOk({ submitted }));
+      } catch (error) {
+        markActionFailure("closeCommitPhase", error, cycleId);
+        respondGatewayError(respond, error);
+      }
+    });
+
+    registerSatSubmissionMethod("sat.sealCycleEntropy", async ({ params, respond }) => {
+      const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
+      try {
+        const cycle = await inspectSatCycle(state.activeConfig, { cycleId });
+        if (cycle.unlockIntervalStartCycleId == null) {
+          throw new Error(`cycle ${cycleId} does not expose its unlock interval start`);
+        }
+        const submitted = await submitSatSealCycleEntropy(state.activeConfig, {
+          cycleId,
+          intervalStartCycleId: cycle.unlockIntervalStartCycleId,
+        });
+        invalidateMiningReadCaches();
+        markActionSuccess("sealCycleEntropy", submitted.txHash, cycleId);
+        await persistRecentActions();
+        respond(true, jsonOk({ submitted }));
+      } catch (error) {
+        markActionFailure("sealCycleEntropy", error, cycleId);
+        respondGatewayError(respond, error);
+      }
+    });
+
+    registerSatSubmissionMethod("sat.revealCycle", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
+        const nonceBase64 = String((params as { nonceBase64?: string })?.nonceBase64 ?? "").trim();
         const allocationFp = Array.isArray((params as { allocationFp?: number[] })?.allocationFp)
           ? ((params as { allocationFp?: number[] }).allocationFp ?? [])
           : [];
-        const request = state.client.buildSubmitCycleRequest({
+        const cycle = await inspectSatCycle(state.activeConfig, { cycleId });
+        if (cycle.unlockIntervalStartCycleId == null) {
+          throw new Error(`cycle ${cycleId} does not expose its unlock interval start`);
+        }
+        const submitted = await submitSatRevealCycle(state.activeConfig, {
           cycleId,
+          intervalStartCycleId: cycle.unlockIntervalStartCycleId,
+          nonceBase64,
           allocationFp,
         });
-        const submitted = await submitSatCycle(state.activeConfig, request.params);
+        invalidateMiningReadCaches();
         await capturePendingPlannerCycle(cycleId);
-        if (Number.isFinite(cycleId) && cycleId >= 0) {
-          const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
-          execution.openRoundSubmitted = true;
-          execution.participationSubmitted = true;
-        }
-        markActionSuccess("submitCycle", submitted.txHash, cycleId);
+        const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
+        execution.openRoundSubmitted = true;
+        execution.commitSubmitted = true;
+        execution.participationSubmitted = true;
+        markActionSuccess("revealCycle", submitted.txHash, cycleId);
         await persistRecentActions();
-        respond(true, jsonOk({ request, submitted }));
+        respond(true, jsonOk({ submitted }));
       } catch (error) {
         state.pendingPlannerCycles.delete(cycleId);
-        if (isCycleMismatchError(error)) {
-          respondGatewayError(respond, error);
-          return;
-        }
-        markActionFailure("submitCycle", error, cycleId);
+        markActionFailure("revealCycle", error, cycleId);
+        respondGatewayError(respond, error);
+      }
+    });
+
+    registerSatSubmissionMethod("sat.releaseUnrevealedCommit", async ({ params, respond }) => {
+      const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
+      try {
+        const minerAuthority = String(
+          (params as { minerAuthority?: string })?.minerAuthority ?? "",
+        ).trim();
+        const submitted = await submitSatReleaseUnrevealedCommit(state.activeConfig, {
+          cycleId,
+          minerAuthority,
+        });
+        invalidateMiningReadCaches();
+        markActionSuccess("releaseUnrevealedCommit", submitted.txHash, cycleId);
+        await persistRecentActions();
+        respond(true, jsonOk({ submitted }));
+      } catch (error) {
+        markActionFailure("releaseUnrevealedCommit", error, cycleId);
+        respondGatewayError(respond, error);
+      }
+    });
+
+    registerSatSubmissionMethod("sat.abortEmptyCycle", async ({ params, respond }) => {
+      const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
+      try {
+        const submitted = await submitSatAbortEmptyCycle(state.activeConfig, { cycleId });
+        invalidateMiningReadCaches();
+        markActionSuccess("abortEmptyCycle", submitted.txHash, cycleId);
+        await persistRecentActions();
+        respond(true, jsonOk({ submitted }));
+      } catch (error) {
+        markActionFailure("abortEmptyCycle", error, cycleId);
         respondGatewayError(respond, error);
       }
     });
 
-    api.registerGatewayMethod("sat.settleCyclePage", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.submitCycle", async ({ respond }) => {
+      respondGatewayError(
+        respond,
+        new Error("public allocation submission is retired; update Fased to use commit/reveal"),
+      );
+    });
+
+    registerSatSubmissionMethod("sat.settleCyclePage", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const pageIndex = Number((params as { pageIndex?: number })?.pageIndex ?? 0);
@@ -7319,7 +7656,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.finalizeCycleSettlement", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.finalizeCycleSettlement", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const pageCount = Number((params as { pageCount?: number })?.pageCount ?? 1);
@@ -7339,7 +7676,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.scoreCyclePage", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.scoreCyclePage", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const pageIndex = Number((params as { pageIndex?: number })?.pageIndex ?? 0);
@@ -7370,7 +7707,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.distributeCyclePage", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.distributeCyclePage", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const pageIndex = Number((params as { pageIndex?: number })?.pageIndex ?? 0);
@@ -7406,20 +7743,21 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.claimCycleRewards", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.claimCycleRewards", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const request = state.client.buildClaimCycleRewardsRequest({ cycleId });
         const submitted = await submitSatClaimCycleRewards(state.activeConfig, request.params);
-        if (Number.isFinite(cycleId) && cycleId >= 0) {
-          const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
-          execution.claimSubmitted = true;
-        }
-        markSatClaimBacklogClaimed(state, [cycleId], submitted.txHash);
-        markActionSuccess("claimCycleRewards", submitted.txHash, cycleId);
+        const completion = await resolveClaimCompletion([cycleId]);
+        applyClaimCompletion({
+          action: "claimCycleRewards",
+          txHash: submitted.txHash,
+          cycleIds: [cycleId],
+          ...completion,
+        });
         await persistRecentActions();
-        void capturePlannerOutcomesForCycles([cycleId], submitted.txHash);
-        respond(true, jsonOk({ request, submitted }));
+        void capturePlannerOutcomesForCycles(completion.resolvedCycleIds, submitted.txHash);
+        respond(true, jsonOk({ request, submitted, ...completion }));
       } catch (error) {
         markSatClaimBacklogFailure(state, [cycleId], error);
         markActionFailure("claimCycleRewards", error, cycleId);
@@ -7427,7 +7765,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.claimCycleRewardsBatch", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.claimCycleRewardsBatch", async ({ params, respond }) => {
       const cycleIds = Array.isArray((params as { cycleIds?: number[] })?.cycleIds)
         ? ((params as { cycleIds?: number[] }).cycleIds ?? [])
             .map((value) => Number(value))
@@ -7437,15 +7775,16 @@ const satMiningPlugin = {
       try {
         markSatClaimBacklogReady(state, cycleIds, "manual claim batch action");
         const submitted = await submitSatClaimCycleRewardsBatch(state.activeConfig, request.params);
-        for (const cycleId of cycleIds) {
-          const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
-          execution.claimSubmitted = true;
-        }
-        markSatClaimBacklogClaimed(state, cycleIds, submitted.txHash);
-        markBatchActionSuccess("claimCycleRewardsBatch", submitted.txHash, cycleIds);
+        const completion = await resolveClaimCompletion(cycleIds);
+        applyClaimCompletion({
+          action: "claimCycleRewardsBatch",
+          txHash: submitted.txHash,
+          cycleIds,
+          ...completion,
+        });
         await persistRecentActions();
-        void capturePlannerOutcomesForCycles(cycleIds, submitted.txHash);
-        respond(true, jsonOk({ request, submitted }));
+        void capturePlannerOutcomesForCycles(completion.resolvedCycleIds, submitted.txHash);
+        respond(true, jsonOk({ request, submitted, ...completion }));
       } catch (error) {
         if (cycleIds.length > 0 && isInvalidAccountOwnerError(error)) {
           const resolvedCycleIds = await resolveClaimBatchInvalidOwnerCycles(cycleIds);
@@ -7492,7 +7831,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.claimBacklog", async ({ respond }) => {
+    registerSatSubmissionMethod("sat.claimBacklog", async ({ respond }) => {
       const batchCycles = resolveSatClaimBatchCycles(state.activeConfig);
       const cycleIds = collectReadySatClaimBacklogCycleIds(state, batchCycles);
       const request = state.client.buildClaimCycleRewardsBatchRequest({ cycleIds });
@@ -7512,19 +7851,21 @@ const satMiningPlugin = {
         }
         markSatClaimBacklogReady(state, cycleIds, "manual claim backlog action");
         const submitted = await submitSatClaimCycleRewardsBatch(state.activeConfig, request.params);
-        for (const cycleId of cycleIds) {
-          const execution = getOrCreateRoundExecutionState(state, cycleId, 0);
-          execution.claimSubmitted = true;
-        }
-        markSatClaimBacklogClaimed(state, cycleIds, submitted.txHash);
-        markBatchActionSuccess("claimCycleRewardsBatch", submitted.txHash, cycleIds);
+        const completion = await resolveClaimCompletion(cycleIds);
+        applyClaimCompletion({
+          action: "claimCycleRewardsBatch",
+          txHash: submitted.txHash,
+          cycleIds,
+          ...completion,
+        });
         await persistRecentActions();
-        void capturePlannerOutcomesForCycles(cycleIds, submitted.txHash);
+        void capturePlannerOutcomesForCycles(completion.resolvedCycleIds, submitted.txHash);
         respond(
           true,
           jsonOk({
             request,
             submitted,
+            ...completion,
             claimBacklog: buildSatClaimBacklogSummary(state),
           }),
         );
@@ -7535,7 +7876,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.retargetUnlock", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.retargetUnlock", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const request = state.client.buildRetargetUnlockRequest({ cycleId });
@@ -7548,7 +7889,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.closeResolvedCycleAccounts", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.closeResolvedCycleAccounts", async ({ params, respond }) => {
       const cycleId = Number((params as { cycleId?: number })?.cycleId ?? 0);
       try {
         const result = await closeResolvedExactCycleAccounts(cycleId);
@@ -7580,7 +7921,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.compactPendingCycleRange", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.compactPendingCycleRange", async ({ params, respond }) => {
       try {
         const maxFrontCycles =
           typeof (params as { maxFrontCycles?: number })?.maxFrontCycles === "number"
@@ -7695,7 +8036,7 @@ const satMiningPlugin = {
       respond(true, jsonOk(await Promise.resolve(readProfile())));
     });
 
-    api.registerGatewayMethod("sat.setMinerProfile", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.setMinerProfile", async ({ params, respond }) => {
       try {
         const request =
           params && typeof params === "object" && !Array.isArray(params)
@@ -7965,10 +8306,14 @@ const satMiningPlugin = {
       ) {
         return;
       }
-      const compacted = await compactPendingCycleRange({
-        maxFrontCycles: SAT_PENDING_RANGE_COMPACT_CHUNK_CYCLES,
-        maxBackCycles: SAT_PENDING_RANGE_COMPACT_CHUNK_CYCLES,
-      }).catch(() => null);
+      const compacted = await runWithSatSubmissionWorkflow(
+        `startup:compact-pending:${authority}:${firstPendingCycleId}:${lastPendingCycleId}`,
+        async () =>
+          await compactPendingCycleRange({
+            maxFrontCycles: SAT_PENDING_RANGE_COMPACT_CHUNK_CYCLES,
+            maxBackCycles: SAT_PENDING_RANGE_COMPACT_CHUNK_CYCLES,
+          }),
+      ).catch(() => null);
       if (compacted?.compacted) {
         api.logger.info(
           `[sat-mining] compacted stale pending range during startup for wallet ${authority}`,
@@ -8081,7 +8426,7 @@ const satMiningPlugin = {
       }, 10_000);
     };
 
-    api.registerGatewayMethod("sat.startMining", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.startMining", async ({ params, respond }) => {
       try {
         if (state.activeConfig.network === "mainnet-beta") {
           const syncStatus = await getSatMainnetSyncStatus();
@@ -8210,7 +8555,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.stopMining", async ({ respond }) => {
+    registerSatSubmissionMethod("sat.stopMining", async ({ params: _params, respond }) => {
       try {
         const authority = await resolveSatCapitalActionAuthority().catch(
           () => state.activeWalletAddress ?? "",
@@ -8344,7 +8689,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.resolveDispute", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.resolveDispute", async ({ params, respond }) => {
       try {
         const request = state.client.buildResolveDisputeRequest({
           disputeAuthority: String(
@@ -8364,7 +8709,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.republishEpochRoots", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.republishEpochRoots", async ({ params, respond }) => {
       try {
         const request = state.client.buildRepublishEpochRootsRequest({
           epochId: Number((params as { epochId?: number })?.epochId ?? 0),
@@ -8483,7 +8828,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.submitValidatorAttestation", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.submitValidatorAttestation", async ({ params, respond }) => {
       try {
         const request = state.client.buildSubmitValidatorAttestationRequest({
           targetAuthority: String((params as { targetAuthority?: string })?.targetAuthority ?? ""),
@@ -8516,7 +8861,7 @@ const satMiningPlugin = {
       }
     });
 
-    api.registerGatewayMethod("sat.openDispute", async ({ params, respond }) => {
+    registerSatSubmissionMethod("sat.openDispute", async ({ params, respond }) => {
       try {
         const request = state.client.buildOpenDisputeRequest({
           targetAuthority: String((params as { targetAuthority?: string })?.targetAuthority ?? ""),