diff --git a/kiosk/src/App.tsx b/kiosk/src/App.tsx
index d23f7086668b..d79b9ef9cd0a 100644
--- a/kiosk/src/App.tsx
+++ b/kiosk/src/App.tsx
@@ -24,6 +24,7 @@ import * as AddingGames from "./Services/AddingGamesService";
 import * as GamepadManager from "./Services/GamepadManager";
 import * as NavGrid from "./Services/NavGrid";
 import * as RectCache from "./Services/RectCache";
+import * as GameRefreshService from "./Services/GameRefreshService";
 import Background from "./Components/Background";
 
 function App() {
@@ -63,6 +64,7 @@ function App() {
             GamepadManager.initialize();
             NavGrid.initialize();
             RectCache.initialize();
+            GameRefreshService.initialize();
         }
     }, [ready]);
 
diff --git a/kiosk/src/Components/GameSlide.tsx b/kiosk/src/Components/GameSlide.tsx
index c18ea5fbd5f6..93236c8f140c 100644
--- a/kiosk/src/Components/GameSlide.tsx
+++ b/kiosk/src/Components/GameSlide.tsx
@@ -1,11 +1,12 @@
-import { useContext } from "react";
+import { useContext, useMemo } from "react";
 import { playSoundEffect } from "../Services/SoundEffectService";
 import { launchGame } from "../Transforms/launchGame";
-import { GameData, HighScore } from "../Types";
+import { GameData } from "../Types";
 import { AppStateContext } from "../State/AppStateContext";
 import HighScoresList from "./HighScoresList";
 import { GameMenu } from "./GameMenu";
 import { getHighScores } from "../State";
+import { getEffectiveGameId } from "../Utils";
 
 interface IProps {
     game: GameData;
@@ -19,13 +20,20 @@ const GameSlide: React.FC<IProps> = ({ game }) => {
         launchGame(game.id);
     };
 
+    const thumbnailUrl = useMemo(() => {
+        if (game) {
+            const gameId = getEffectiveGameId(game);
+            return `url("https://makecode.com/api/${gameId}/thumb")`;
+        }
+    }, [game, game?.tempGameId]);
+
     return (
         <div className="gameTile" onClick={handleSlideClick}>
             <div className="gameSelectionIndicator" />
             <div
                 className="gameThumbnail"
                 style={{
-                    backgroundImage: `url("https://makecode.com/api/${game.id}/thumb")`,
+                    backgroundImage: thumbnailUrl,
                 }}
             />
 
diff --git a/kiosk/src/Components/PlayingGame.tsx b/kiosk/src/Components/PlayingGame.tsx
index 9cc3d25a9a07..4b193d828b0e 100644
--- a/kiosk/src/Components/PlayingGame.tsx
+++ b/kiosk/src/Components/PlayingGame.tsx
@@ -1,16 +1,20 @@
 import { useContext, useEffect, useMemo, useState } from "react";
 import { AppStateContext } from "../State/AppStateContext";
+import { getLaunchedGame } from "../State";
 import { escapeGame } from "../Transforms/escapeGame";
 import { playSoundEffect } from "../Services/SoundEffectService";
 import { useOnControlPress } from "../Hooks";
-import { stringifyQueryString } from "../Utils";
+import { getEffectiveGameId, stringifyQueryString } from "../Utils";
 import * as GamepadManager from "../Services/GamepadManager";
 import * as IndexedDb from "../Services/IndexedDb";
 import configData from "../config.json";
 
 export default function PlayingGame() {
     const { state: kiosk, dispatch } = useContext(AppStateContext);
-    const { launchedGameId: gameId } = kiosk;
+
+    const launchedGame = useMemo(() => {
+        return getLaunchedGame();
+    }, [kiosk.launchedGameId]);
 
     // Handle Back and Start button presses
     useOnControlPress(
@@ -29,19 +33,22 @@ export default function PlayingGame() {
     >(undefined);
 
     useEffect(() => {
-        if (gameId) {
+        if (launchedGame) {
+            const gameId = getEffectiveGameId(launchedGame);
             // Try to fetch the built game from local storage.
-            IndexedDb.getBuiltJsInfoAsync(gameId).then(builtGame => {
-                setBuiltJsInfo(builtGame);
-                setFetchingBuiltJsInfo(false);
-            });
+            IndexedDb.getBuiltJsInfoAsync(gameId).then(
+                builtGame => {
+                    setBuiltJsInfo(builtGame);
+                    setFetchingBuiltJsInfo(false);
+                }
+            );
         }
-    }, [gameId]);
+    }, [launchedGame]);
 
     const playUrl = useMemo(() => {
-        if (gameId && !fetchingBuiltJsInfo) {
+        if (launchedGame && !fetchingBuiltJsInfo) {
             return stringifyQueryString(configData.PlayUrlRoot, {
-                id: gameId,
+                id: getEffectiveGameId(launchedGame),
                 // TODO: Show sim buttons on mobile & touch devices.
                 hideSimButtons: pxt.BrowserUtils.isMobile() ? undefined : 1,
                 noFooter: 1,
@@ -58,7 +65,7 @@ export default function PlayingGame() {
                 sendBuilt: builtJsInfo ? undefined : 1,
             });
         }
-    }, [gameId, fetchingBuiltJsInfo]);
+    }, [launchedGame, fetchingBuiltJsInfo]);
 
     return (
         <iframe
diff --git a/kiosk/src/Services/BackendRequests.ts b/kiosk/src/Services/BackendRequests.ts
index 5fbf1249f9e6..a39f180426cd 100644
--- a/kiosk/src/Services/BackendRequests.ts
+++ b/kiosk/src/Services/BackendRequests.ts
@@ -1,4 +1,4 @@
-import { ShareIds, GameInfo } from "../Types";
+import { ShareIds } from "../Types";
 
 export const getGameCodesAsync = async (
     kioskCode: string
@@ -72,7 +72,7 @@ export const canthrow_addGameToKioskAsync = async (
 
 export const getGameDetailsAsync = async (
     gameId: string
-): Promise<GameInfo | undefined> => {
+): Promise<pxt.Cloud.JsonScript | undefined> => {
     try {
         const gameDetailsUrl = `${pxt.Cloud.apiRoot}/${gameId}`;
         const response = await fetch(gameDetailsUrl);
@@ -80,7 +80,6 @@ export const getGameDetailsAsync = async (
             throw new Error("Unable to fetch the game details");
         } else {
             const gameDetails = await response.json();
-            console.log("Game details: " + gameDetails);
             return gameDetails;
         }
     } catch (error) {
diff --git a/kiosk/src/Services/GameRefreshService.ts b/kiosk/src/Services/GameRefreshService.ts
new file mode 100644
index 000000000000..14594cfaa5b2
--- /dev/null
+++ b/kiosk/src/Services/GameRefreshService.ts
@@ -0,0 +1,75 @@
+import { secondsToMs, minutesToMs } from "../Utils";
+import { stateAndDispatch } from "../State";
+import * as Storage from "./LocalStorage";
+import { getGameDetailsAsync } from "./BackendRequests";
+import * as Actions from "../State/Actions";
+import { safeGameName, safeGameDescription, isPersistentGameId } from "../Utils";
+
+const REFRESH_TIMER_INTERVAL_MS = secondsToMs(15);
+const GAME_NEEDS_REFRESH_MS = minutesToMs(1);
+
+let refreshTimer: NodeJS.Timeout | undefined;
+
+// Periodically refreshes the metadata for "persistent share" games, i.e. games
+// that can be updated without their share ID changing.
+async function refreshOneAsync() {
+    const { state, dispatch } = stateAndDispatch();
+
+    const nowMs = Date.now();
+
+    const userAddedGames = Object.values(Storage.getUserAddedGames());
+
+    for (const game of userAddedGames) {
+        // Only refresh persistent share games
+        if (!isPersistentGameId(game.id)) continue;
+        // Don't refresh deleted games
+        if (game.deleted) continue;
+
+        const lastRefreshMs = game.lastRefreshMs ?? 0;
+
+        if (lastRefreshMs + GAME_NEEDS_REFRESH_MS < nowMs) {
+            //console.log(`Refreshing game ${game.id}`);
+            const details = await getGameDetailsAsync(game.id);
+            if (details) {
+                if (details.id !== game.tempGameId) {
+                    // The temporary gameId changed, update local copy of game metadata
+                    dispatch(
+                        Actions.updateGame(game.id, {
+                            name: safeGameName(details.name),
+                            description: safeGameDescription(
+                                details.description
+                            ),
+                            tempGameId: details.id,
+                        })
+                    );
+                    //console.log(`Refreshed game ${game.id} ${details.name}`);
+                    // Update a maximum of one game per refresh cycle
+                    break;
+                } else {
+                    //console.log(`Did not refresh game ${game.id}`);
+                    // Poke the game to refresh the lastRefreshMs timestamp
+                    dispatch(Actions.updateGame(game.id, {}));
+                }
+            }
+        }
+    }
+
+    // Schedule the next refresh
+    refreshTimer = setTimeout(
+        refreshOneAsync,
+        // Slightly randomize the interval to avoid multiple timers in the app
+        // on the same interval to perfectly align
+        REFRESH_TIMER_INTERVAL_MS + (Math.random() * 1000) | 0
+    );
+}
+
+let initializeOnce = () => {
+    initializeOnce = () => {
+        throw new Error("GamepadManager.initialize() called more than once.");
+    };
+    refreshTimer = setTimeout(refreshOneAsync, REFRESH_TIMER_INTERVAL_MS);
+};
+
+export function initialize() {
+    initializeOnce();
+}
diff --git a/kiosk/src/Services/IndexedDb.ts b/kiosk/src/Services/IndexedDb.ts
index 5cda3e2d899e..01873aeac0e5 100644
--- a/kiosk/src/Services/IndexedDb.ts
+++ b/kiosk/src/Services/IndexedDb.ts
@@ -1,4 +1,5 @@
 import { openDB, IDBPDatabase } from "idb";
+import { isPersistentGameId } from "../Utils";
 
 class KioskDb {
     db: IDBPDatabase | undefined;
@@ -61,7 +62,7 @@ class KioskDb {
     ): Promise<void> {
         const ver = pxt.appTarget?.versions?.target;
         if (!ver) return;
-        if (/^S/.test(gameId)) return; // skip persistent-share games for now (need to get their actual gameId and use that as the key)
+        if (isPersistentGameId(gameId)) return; // disallow keying to persistent-share gameIds (a safety measure. shouldn't happen in practice)
         const key = `${ver}:${gameId}`;
         await this.setAsync("builtjs", key, info);
     }
diff --git a/kiosk/src/Services/SimHostService.ts b/kiosk/src/Services/SimHostService.ts
index 384e73ed7d54..fb192c28baef 100644
--- a/kiosk/src/Services/SimHostService.ts
+++ b/kiosk/src/Services/SimHostService.ts
@@ -1,11 +1,11 @@
-import { stateAndDispatch } from "../State";
+import { stateAndDispatch, getLaunchedGame } from "../State";
 import * as Actions from "../State/Actions";
 import * as Constants from "../Constants";
 import { gameOver } from "../Transforms/gameOver";
 import { resetHighScores } from "../Transforms/resetHighScores";
 import * as GamepadManager from "./GamepadManager";
 import { postNotification } from "../Transforms/postNotification";
-import { makeNotification } from "../Utils";
+import { getEffectiveGameId, makeNotification } from "../Utils";
 import * as IndexedDb from "./IndexedDb";
 
 export function initialize() {
@@ -78,8 +78,10 @@ export function initialize() {
 
     window.addEventListener("message", async (event) => {
         const { state, dispatch } = stateAndDispatch();
-        if (event.data?.js && state.launchedGameId) {
-            await IndexedDb.setBuiltJsInfoAsync(state.launchedGameId, event.data);
+        const launchedGame = getLaunchedGame();
+        if (event.data?.js && launchedGame) {
+            const gameId = getEffectiveGameId(launchedGame);
+            await IndexedDb.setBuiltJsInfoAsync(gameId, event.data);
         }
         switch (event.data.type) {
             case "simulator":
@@ -111,9 +113,9 @@ export function initialize() {
                 break;
 
             case "ready":
-                const builtGame = await IndexedDb.getBuiltJsInfoAsync(state.launchedGameId!);
-                if (builtGame) {
-                    await sendBuiltGameAsync(state.launchedGameId!);
+                if (launchedGame) {
+                    const gameId = getEffectiveGameId(launchedGame);
+                    await sendBuiltGameAsync(gameId);
                 }
                 break;
         }
diff --git a/kiosk/src/State/Actions.ts b/kiosk/src/State/Actions.ts
index 97370d0f91ec..6cd84ee7767f 100644
--- a/kiosk/src/State/Actions.ts
+++ b/kiosk/src/State/Actions.ts
@@ -61,6 +61,12 @@ type RemoveGame = ActionBase & {
     gameId: string;
 };
 
+type UpdateGame = ActionBase & {
+    type: "UPDATE_GAME";
+    gameId: string;
+    gameData: Partial<GameData>;
+};
+
 type SaveHighScore = ActionBase & {
     type: "SAVE_HIGH_SCORE";
     gameId: string;
@@ -137,6 +143,7 @@ export type Action =
     | SetVolume
     | AddGame
     | RemoveGame
+    | UpdateGame
     | SaveHighScore
     | LoadHighScores
     | SetMostRecentScores
@@ -200,6 +207,12 @@ const removeGame = (gameId: string): RemoveGame => ({
     gameId,
 });
 
+const updateGame = (gameId: string, gameData: Partial<GameData>): UpdateGame => ({
+    type: "UPDATE_GAME",
+    gameId,
+    gameData
+});
+
 const saveHighScore = (
     gameId: string,
     highScore: HighScoreWithId
@@ -279,6 +292,7 @@ export {
     setVolume,
     addGame,
     removeGame,
+    updateGame,
     saveHighScore,
     loadHighScores,
     setMostRecentScores,
diff --git a/kiosk/src/State/Reducer.ts b/kiosk/src/State/Reducer.ts
index 4129ecc47459..65c0922a2caf 100644
--- a/kiosk/src/State/Reducer.ts
+++ b/kiosk/src/State/Reducer.ts
@@ -1,4 +1,3 @@
-import { nanoid } from "nanoid";
 import { AppState } from "./State";
 import { Action } from "./Actions";
 import * as Storage from "../Services/LocalStorage";
@@ -55,28 +54,82 @@ export default function reducer(state: AppState, action: Action): AppState {
             };
         }
         case "ADD_GAME": {
-            const allGames = [...state.allGames, action.game];
+            const existing = state.allGames.find(g => g.id === action.game.id);
+            if (existing && !existing.deleted) {
+                return state;
+            }
+            const game = {
+                ...existing,
+                ...action.game,
+                lastRefreshMs: Date.now(),
+                deleted: false,
+            };
+            // User-added? Persist the change
+            if (action.game.userAdded) {
+                const userAddedGames = Storage.getUserAddedGames();
+                userAddedGames[action.game.id] = game;
+                Storage.setUserAddedGames(userAddedGames);
+            }
+            const remainingGames = state.allGames.filter(
+                g => g.id !== action.game.id
+            );
+            const allGames = [...remainingGames, game];
             return {
                 ...state,
                 allGames,
+                selectedGameId: game.id,
             };
         }
         case "REMOVE_GAME": {
-            const allGames = state.allGames.filter(g => g.id !== action.gameId);
-            const selectedGameIndex = state.allGames.findIndex(
-                g => g.id === action.gameId
-            );
-            if (selectedGameIndex !== -1) {
-                // Try to select the next game in the list, or the previous game if there is no next game.
-                let selectedGameId = undefined;
-                if (selectedGameIndex < allGames.length - 1) {
-                    selectedGameId = allGames[selectedGameIndex].id;
-                } else if (allGames.length > 0) {
-                    selectedGameId = allGames[allGames.length - 1].id;
+            // User-added? Persist the change
+            const userAddedGames = Storage.getUserAddedGames();
+            if (userAddedGames[action.gameId]) {
+                userAddedGames[action.gameId].deleted = true;
+                Storage.setUserAddedGames(userAddedGames);
+            }
+            const remainingGames = state.allGames.filter(g => g.id !== action.gameId);
+            let selectedGameId: string | undefined;
+            // If the deleted game was the selected game, select the next game in the list.
+            if (state.selectedGameId === action.gameId) {
+                // Get the index of the now-deleted game in the original list.
+                const selectedGameIndex = state.allGames.findIndex(g => g.id === action.gameId);
+                if (selectedGameIndex >= 0) {
+                    if (selectedGameIndex > remainingGames.length - 1) {
+                        // The index of the deleted game is beyond the bounds of the updated list. Select the last game in the updated list.
+                        selectedGameId = remainingGames[remainingGames.length - 1].id;
+                    } else {
+                        // The index of the deleted game is within the bounds of the updated list. Select the new game appearing at that index.
+                        selectedGameId = remainingGames[selectedGameIndex].id;
+                    }
+                }
+            }
+            return {
+                ...state,
+                selectedGameId,
+                allGames: remainingGames,
+            };
+        }
+        case "UPDATE_GAME": {
+            let existing = state.allGames.find(g => g.id === action.gameId);
+            if (existing) {
+                const index = state.allGames.findIndex(
+                    g => g.id === action.gameId
+                );
+                existing = {
+                    ...existing,
+                    lastRefreshMs: Date.now(),
+                    ...action.gameData, // can overwrite lastRefreshMs
+                };
+                const allGames = [...state.allGames];
+                allGames[index] = existing;
+                // User-added? Persist the change
+                if (existing.userAdded) {
+                    const userAddedGames = Storage.getUserAddedGames();
+                    userAddedGames[action.gameId] = existing;
+                    Storage.setUserAddedGames(userAddedGames);
                 }
                 return {
                     ...state,
-                    selectedGameId,
                     allGames,
                 };
             } else {
@@ -88,7 +141,7 @@ export default function reducer(state: AppState, action: Action): AppState {
             const allHighScores = { ...state.allHighScores };
             const highScores = allHighScores[gameId] || [];
             // Before saving this high score, ensure we don't already have it recorded.
-            // React is mean and will sometimes dispatch the action the reducer multiple times to flush out non-idempotent logic (development mode only).
+            // Protect against duplicate action dispatches.
             if (!highScores.find(hs => hs.id === highScore.id)) {
                 highScores.push(highScore);
                 highScores.sort((first, second) => second.score - first.score);
@@ -160,7 +213,7 @@ export default function reducer(state: AppState, action: Action): AppState {
         }
         case "POST_NOTIFICATION": {
             // Before posting the notification, ensure is doesn't already exist in the list.
-            // React is mean and will sometimes dispatch the action the reducer multiple times to flush out non-idempotent logic (development mode only).
+            // Protect against duplicate action dispatches.
             if (
                 !state.notifications.find(n => n.id === action.notification.id)
             ) {
diff --git a/kiosk/src/State/index.ts b/kiosk/src/State/index.ts
index 2f25d4250f90..3f2760cde62f 100644
--- a/kiosk/src/State/index.ts
+++ b/kiosk/src/State/index.ts
@@ -1,4 +1,4 @@
-import { HighScore } from "../Types";
+import { HighScore, GameData } from "../Types";
 import { stateAndDispatch } from "./AppStateContext";
 
 function getHighScores(gameId: string | undefined): HighScore[] {
@@ -22,9 +22,21 @@ function getSelectedGameId(): string | undefined {
     return state.selectedGameId;
 }
 
+function getSelectedGame(): GameData | undefined {
+    const { state } = stateAndDispatch();
+    return state.allGames.find(game => game.id === state.selectedGameId);
+}
+
+function getLaunchedGame(): GameData | undefined {
+    const { state } = stateAndDispatch();
+    return state.allGames.find(game => game.id === state.launchedGameId);
+}
+
 export {
     stateAndDispatch,
     getHighScores,
     getSelectedGameIndex,
     getSelectedGameId,
+    getSelectedGame,
+    getLaunchedGame,
 };
diff --git a/kiosk/src/Transforms/saveNewGamesAsync.ts b/kiosk/src/Transforms/saveNewGamesAsync.ts
index 6b8428647180..cc9848a10e2c 100644
--- a/kiosk/src/Transforms/saveNewGamesAsync.ts
+++ b/kiosk/src/Transforms/saveNewGamesAsync.ts
@@ -1,61 +1,95 @@
 import { stateAndDispatch } from "../State";
 import { getGameDetailsAsync } from "../Services/BackendRequests";
-import { safeGameName, safeGameDescription } from "../Utils";
-import * as Constants from "../Constants";
+import {
+    safeGameName,
+    safeGameDescription,
+    isPersistentGameId,
+} from "../Utils";
 import * as Storage from "../Services/LocalStorage";
 import * as Actions from "../State/Actions";
 import { GameData, ShareIds } from "../Types";
 import { selectGame } from "./selectGame";
 
-export async function saveNewGamesAsync(games: ShareIds): Promise<GameData[]> {
-    const { state, dispatch } = stateAndDispatch();
-    const allAddedGames = Storage.getUserAddedGames();
-    let gamesToAdd: GameData[] = [];
-    const shareIds = Object.keys(games);
+export async function saveNewGamesAsync(
+    incoming: ShareIds
+): Promise<GameData[]> {
+    const dateStr = () =>
+        new Date().toLocaleString(undefined, {
+            year: "numeric",
+            month: "numeric",
+            day: "numeric",
+            minute: "numeric",
+            hour: "numeric",
+        });
+
+    const { dispatch } = stateAndDispatch();
+    const userAddedGames = Storage.getUserAddedGames();
+    let result: GameData[] = [];
+    const shareIds = Object.keys(incoming);
+
     for (const shareId of shareIds) {
-        if (!allAddedGames[shareId]) {
-            let gameName;
-            let gameDescription;
+        if (!userAddedGames[shareId]) {
+            // Game not found locally, add it.
 
+            // Fetch the metadata
             const gameDetails = await getGameDetailsAsync(shareId);
-            gameName = safeGameName(gameDetails?.name);
-            gameDescription = safeGameDescription(gameDetails?.description);
+            const gameName = safeGameName(gameDetails?.name);
+            const gameDescription = safeGameDescription(
+                gameDetails?.description
+            );
 
-            const gameUploadDate = new Date().toLocaleString(undefined, {
-                year: "numeric",
-                month: "numeric",
-                day: "numeric",
-                minute: "numeric",
-                hour: "numeric",
-            });
             const newGame: GameData = {
                 id: shareId,
                 name: gameName,
                 description: gameDescription,
                 highScoreMode: "None",
-                uniqueIdentifier: games[shareId].id,
-                date: gameUploadDate,
+                uniqueIdentifier: incoming[shareId].id,
+                date: dateStr(),
                 userAdded: true,
+                tempGameId: gameDetails?.id
             };
 
             dispatch(Actions.addGame(newGame));
-            gamesToAdd.push(newGame);
-            allAddedGames[shareId] = newGame;
-        } else if (allAddedGames[shareId]?.deleted) {
-            if (games[shareId].id !== allAddedGames[shareId].uniqueIdentifier) {
-                allAddedGames[shareId].uniqueIdentifier = games[shareId].id;
-                allAddedGames[shareId].deleted = false;
-                gamesToAdd.push(allAddedGames[shareId]);
-                dispatch(Actions.addGame(allAddedGames[shareId]));
+            result.push(newGame);
+        } else if (userAddedGames[shareId]?.deleted) {
+            // Game found locally in deleted form. Restore it.
+            const existing = userAddedGames[shareId];
+            if (incoming[shareId].id !== existing.uniqueIdentifier) {
+                // If it's a persistent share game, grab the latest metadata
+                if (isPersistentGameId(shareId)) {
+                    const gameDetails = await getGameDetailsAsync(shareId);
+                    existing.name = safeGameName(gameDetails?.name);
+                    existing.description = safeGameDescription(
+                        gameDetails?.description
+                    );
+                    existing.tempGameId = gameDetails?.id;
+                }
+                existing.date = dateStr();
+                existing.uniqueIdentifier = incoming[shareId].id;
+                dispatch(Actions.addGame(existing));
+                result.push(existing);
             }
         } else {
-            // we need to keep the backend and frontend unique identifiers the same
-            allAddedGames[shareId].uniqueIdentifier = games[shareId].id;
+            if (
+                incoming[shareId].id !==
+                userAddedGames[shareId].uniqueIdentifier
+            ) {
+                // we need to keep the backend and frontend unique identifiers the same
+                dispatch(
+                    Actions.updateGame(shareId, {
+                        uniqueIdentifier: incoming[shareId].id,
+                        lastRefreshMs: userAddedGames[shareId].lastRefreshMs, // Preserve current refresh timestamp
+                    })
+                );
+                // Game exists locally, but we still want to add it to
+                // the result list so we can show a notification that it was
+                // received.
+                result.push(userAddedGames[shareId]);
+            }
         }
     }
-    if (gamesToAdd.length) {
-        selectGame(gamesToAdd[0].id);
+    if (result.length) {
+        selectGame(result[0].id);
     }
-    Storage.setUserAddedGames(allAddedGames);
-    return gamesToAdd;
+    return result;
 }
diff --git a/kiosk/src/Types/index.ts b/kiosk/src/Types/index.ts
index ebd265ac936c..43d6e79e719e 100644
--- a/kiosk/src/Types/index.ts
+++ b/kiosk/src/Types/index.ts
@@ -1,5 +1,5 @@
 export type GameData = {
-    id: string;
+    id: string; // If this is a persistent share game, this is the persistent game id and `tempGameId` will contain the temporary game id. Otherwise, it's the regular game Id.
     name: string;
     description: string;
     highScoreMode: string;
@@ -7,6 +7,8 @@ export type GameData = {
     date?: string;
     userAdded?: boolean;
     deleted?: boolean;
+    lastRefreshMs?: number; // The last time we refreshed the game from the backend (applies to user-added, persistent shares only)
+    tempGameId?: string; // If this is a persistent share game, this is the temp game Id
 };
 
 export type HighScore = {
@@ -52,11 +54,6 @@ export type Notifications = NotificationWithId[];
 
 export type ShareIds = { [index: string]: ShareId };
 
-export type GameInfo = {
-    name: string;
-    description: string;
-};
-
 export type ModalId = "delete-game-confirmation";
 
 export type DeleteGameModal = {
diff --git a/kiosk/src/Utils/index.ts b/kiosk/src/Utils/index.ts
index f554b1a06679..d3c6b15f8e43 100644
--- a/kiosk/src/Utils/index.ts
+++ b/kiosk/src/Utils/index.ts
@@ -1,6 +1,6 @@
 import { nanoid } from "nanoid";
 import * as Constants from "../Constants";
-import { HighScoreWithId, NotificationWithId } from "../Types";
+import { HighScoreWithId, NotificationWithId, GameData } from "../Types";
 
 export function safeGameName(name: string | undefined): string {
     if (!name || name.toLowerCase() === "untitled") {
@@ -85,3 +85,23 @@ export function stringifyQueryString(url: string, qs: any) {
     }
     return url;
 }
+
+export function minutesToMs(mins: number): number {
+    return (mins * 60 * 1000) | 0;
+}
+
+export function secondsToMs(secs: number): number {
+    return (secs * 1000) | 0;
+}
+
+export function minutesToSecs(mins: number): number {
+    return (mins * 60) | 0;
+}
+
+export function isPersistentGameId(id: string): boolean {
+    return /^S/i.test(id);
+}
+
+export function getEffectiveGameId(game: GameData): string {
+    return game.tempGameId ?? game.id;
+}
diff --git a/pxtlib/emitter/cloud.ts b/pxtlib/emitter/cloud.ts
index b034153ca288..69bc9cdf60eb 100644
--- a/pxtlib/emitter/cloud.ts
+++ b/pxtlib/emitter/cloud.ts
@@ -293,5 +293,6 @@ namespace pxt.Cloud {
         targetVersion?: string;
         meta?: JsonScriptMeta; // only in lite, bag of metadata
         thumb?: boolean;
+        persistId?: string;
     }
 }