diff --git a/.gitignore b/.gitignore
index 0726b2d7..e71594b5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,3 +38,4 @@ mobile/ios/App/ForgeApp/Generated/
 todos/*.md
 !todos/.gitkeep
 forge.code-workspace
+.worktrees
diff --git a/apps/cms/src/admin/pages/SystemStatus.tsx b/apps/cms/src/admin/pages/SystemStatus.tsx
index 5abed233..ef78cb03 100644
--- a/apps/cms/src/admin/pages/SystemStatus.tsx
+++ b/apps/cms/src/admin/pages/SystemStatus.tsx
@@ -26,6 +26,11 @@ type PhaseResult = {
   errors: number
 }
 
+type PhaseWatermark = {
+  phase: string
+  lastSyncedAt: string
+}
+
 type SyncStatus = {
   inProgress: boolean
   lastRun: string | null
@@ -39,6 +44,15 @@ type SyncStatus = {
     duration?: number
     error?: string
   } | null
+  isProduction?: boolean
+  // Persisted data (available after restart)
+  persistedLastRun?: string | null
+  phaseWatermarks?: PhaseWatermark[]
+}
+
+type LocalImport = {
+  lastImportedAt: string | null
+  snapshotKey: string | null
 }
 
 type SnapshotStatus = {
@@ -50,6 +64,16 @@ type SnapshotStatus = {
     sizeBytes?: number
     error?: string
   } | null
+  isProduction?: boolean
+  // Persisted data (available after restart)
+  persistedLastRun?: string | null
+  latestSnapshot?: {
+    key: string
+    lastModified: string
+    sizeBytes: number
+  } | null
+  // Local import data (non-production only)
+  localImport?: LocalImport | null
 }
 
 function formatBytes(bytes: number): string {
@@ -144,6 +168,56 @@ function PhaseResultsTable({ phases }: { phases: PhaseResult[] }) {
   )
 }
 
+function PhaseWatermarksTable({
+  watermarks,
+}: {
+  watermarks: PhaseWatermark[]
+}) {
+  if (watermarks.length === 0) return null
+
+  return (
+    <Box paddingTop={2}>
+      <Typography variant="sigma" textColor="neutral600">
+        Phase watermarks (from database)
+      </Typography>
+      <table style={{ width: "100%", borderCollapse: "collapse" }}>
+        <thead>
+          <tr>
+            {["Phase", "Last Synced"].map((h) => (
+              <th
+                key={h}
+                style={{
+                  textAlign: "left",
+                  padding: "4px 8px",
+                  borderBottom: "1px solid #ddd",
+                }}
+              >
+                <Typography variant="sigma" textColor="neutral600">
+                  {h}
+                </Typography>
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {watermarks.map((w) => (
+            <tr key={w.phase}>
+              <td style={{ padding: "4px 8px" }}>
+                <Typography variant="omega">{w.phase}</Typography>
+              </td>
+              <td style={{ padding: "4px 8px" }}>
+                <Typography variant="omega">
+                  {formatTime(w.lastSyncedAt)}
+                </Typography>
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </Box>
+  )
+}
+
 function SyncCard({
   status,
   onTrigger,
@@ -155,6 +229,10 @@ function SyncCard({
 }) {
   const inProgress = status?.inProgress ?? false
   const error = status?.lastResult?.error
+  const isProduction = status?.isProduction ?? false
+
+  // Use in-memory lastRun, or fall back to persisted watermark time
+  const effectiveLastRun = status?.lastRun ?? status?.persistedLastRun ?? null
 
   return (
     <Box background="neutral0" padding={6} shadow="tableShadow" hasRadius>
@@ -165,12 +243,22 @@ function SyncCard({
         <StateBadge inProgress={inProgress} error={error} />
       </Flex>
 
-      {status?.lastRun && (
+      {!isProduction && (
+        <Box paddingTop={2}>
+          <Alert variant="default" title="Development mode" closeLabel="Close">
+            Core sync is disabled outside production. Use{" "}
+            <code>pnpm data-import</code> to restore a snapshot locally.
+          </Alert>
+        </Box>
+      )}
+
+      {effectiveLastRun && (
         <Box paddingTop={2}>
           <Typography variant="omega" textColor="neutral600">
-            Last run: {formatTime(status.lastRun)}
-            {status.lastResult?.duration &&
+            Last run: {formatTime(effectiveLastRun)}
+            {status?.lastResult?.duration &&
               ` (${formatDuration(status.lastResult.duration)})`}
+            {!status?.lastRun && status?.persistedLastRun && " (from database)"}
           </Typography>
         </Box>
       )}
@@ -201,6 +289,13 @@ function SyncCard({
         <PhaseResultsTable phases={status.lastResult.phases} />
       )}
 
+      {!inProgress &&
+        !status?.lastResult?.phases &&
+        status?.phaseWatermarks &&
+        status.phaseWatermarks.length > 0 && (
+          <PhaseWatermarksTable watermarks={status.phaseWatermarks} />
+        )}
+
       {error && (
         <Box paddingTop={3}>
           <Alert variant="danger" title="Sync failed" closeLabel="Close">
@@ -209,16 +304,18 @@ function SyncCard({
         </Box>
       )}
 
-      <Box paddingTop={4}>
-        <Button
-          onClick={onTrigger}
-          disabled={inProgress || triggering}
-          loading={triggering}
-          variant="secondary"
-        >
-          Sync Now
-        </Button>
-      </Box>
+      {isProduction && (
+        <Box paddingTop={4}>
+          <Button
+            onClick={onTrigger}
+            disabled={inProgress || triggering}
+            loading={triggering}
+            variant="secondary"
+          >
+            Sync Now
+          </Button>
+        </Box>
+      )}
     </Box>
   )
 }
@@ -236,6 +333,16 @@ function SnapshotCard({
 }) {
   const inProgress = status?.inProgress ?? false
   const error = status?.lastResult?.error
+  const isProduction = status?.isProduction ?? false
+
+  // Use in-memory lastRun, or fall back to persisted S3 metadata
+  const effectiveLastRun = status?.lastRun ?? status?.persistedLastRun ?? null
+  const effectiveSize =
+    status?.lastResult?.sizeBytes ?? status?.latestSnapshot?.sizeBytes ?? null
+  const effectiveKey =
+    status?.lastResult?.key ?? status?.latestSnapshot?.key ?? null
+
+  const localImport = status?.localImport
 
   return (
     <Box background="neutral0" padding={6} shadow="tableShadow" hasRadius>
@@ -246,24 +353,66 @@ function SnapshotCard({
         <StateBadge inProgress={inProgress} error={error} />
       </Flex>
 
-      {status?.lastRun && (
+      {!isProduction && (
+        <Box paddingTop={2}>
+          <Alert variant="default" title="Development mode" closeLabel="Close">
+            Snapshot creation is disabled outside production. Use{" "}
+            <code>pnpm data-import</code> to download a snapshot locally.
+          </Alert>
+        </Box>
+      )}
+
+      {isProduction && effectiveLastRun && (
         <Box paddingTop={2}>
           <Typography variant="omega" textColor="neutral600">
-            Last snapshot: {formatTime(status.lastRun)}
-            {status.lastResult?.duration &&
+            Last snapshot: {formatTime(effectiveLastRun)}
+            {status?.lastResult?.duration &&
               ` (${formatDuration(status.lastResult.duration)})`}
+            {!status?.lastRun && status?.persistedLastRun && " (from S3)"}
+          </Typography>
+        </Box>
+      )}
+
+      {isProduction && effectiveKey && (
+        <Box paddingTop={1}>
+          <Typography variant="omega" textColor="neutral600">
+            Key: {effectiveKey}
           </Typography>
         </Box>
       )}
 
-      {status?.lastResult?.sizeBytes && (
+      {effectiveSize && (
         <Box paddingTop={1}>
           <Typography variant="omega" textColor="neutral600">
-            Size: {formatBytes(status.lastResult.sizeBytes)}
+            Size: {formatBytes(effectiveSize)}
           </Typography>
         </Box>
       )}
 
+      {!isProduction && localImport && (
+        <Box paddingTop={2}>
+          {localImport.lastImportedAt ? (
+            <>
+              <Typography variant="omega" textColor="neutral600">
+                Last local import: {formatTime(localImport.lastImportedAt)}
+              </Typography>
+              {localImport.snapshotKey && (
+                <Box paddingTop={1}>
+                  <Typography variant="omega" textColor="neutral600">
+                    Snapshot: {localImport.snapshotKey}
+                  </Typography>
+                </Box>
+              )}
+            </>
+          ) : (
+            <Typography variant="omega" textColor="neutral600">
+              No local import recorded. Run <code>pnpm data-import</code> to
+              restore production data.
+            </Typography>
+          )}
+        </Box>
+      )}
+
       {inProgress && (
         <Box paddingTop={3}>
           <Flex alignItems="center" gap={2}>
@@ -282,15 +431,17 @@ function SnapshotCard({
       )}
 
       <Flex paddingTop={4} gap={2}>
-        <Button
-          onClick={onTrigger}
-          disabled={inProgress || triggering}
-          loading={triggering}
-          variant="secondary"
-        >
-          Create Snapshot
-        </Button>
-        {downloadUrl && !inProgress && (
+        {isProduction && (
+          <Button
+            onClick={onTrigger}
+            disabled={inProgress || triggering}
+            loading={triggering}
+            variant="secondary"
+          >
+            Create Snapshot
+          </Button>
+        )}
+        {isProduction && downloadUrl && !inProgress && (
           <Button
             variant="tertiary"
             tag="a"
@@ -330,6 +481,8 @@ export default function SystemStatusPage() {
     if (snapRes.status === "fulfilled") setSnapshotStatus(snapRes.value.data)
   }, [get])
 
+  const isProduction = syncStatus?.isProduction ?? snapshotStatus?.isProduction
+
   const fetchDownloadUrl = useCallback(async () => {
     try {
       const res = await get<{ url: string }>(
@@ -408,7 +561,11 @@ export default function SystemStatusPage() {
     <Page.Main>
       <Layouts.Header
         title="Core Sync Status"
-        subtitle="Core sync and data snapshot operations"
+        subtitle={
+          isProduction === false
+            ? "Development mode — sync and snapshot triggers are disabled"
+            : "Core sync and data snapshot operations"
+        }
       />
       <Layouts.Content>
         <Grid.Root gap={6}>
diff --git a/apps/cms/src/api/core-sync/controllers/core-sync.ts b/apps/cms/src/api/core-sync/controllers/core-sync.ts
index 6223c4a0..d19b4aca 100644
--- a/apps/cms/src/api/core-sync/controllers/core-sync.ts
+++ b/apps/cms/src/api/core-sync/controllers/core-sync.ts
@@ -1,5 +1,10 @@
 import type { Core } from "@strapi/strapi"
-import { runSync, resolveScope, getSyncStatus } from "../services/core-sync"
+import {
+  runSync,
+  resolveScope,
+  getSyncStatus,
+  getPersistedSyncStatus,
+} from "../services/core-sync"
 import { formatError } from "../services/strapi-helpers"
 
 type StrapiContext = {
@@ -10,6 +15,15 @@ type StrapiContext = {
 
 export default ({ strapi }: { strapi: Core.Strapi }) => ({
   async trigger(ctx: StrapiContext) {
+    if (process.env.NODE_ENV !== "production") {
+      ctx.status = 403
+      ctx.body = {
+        error:
+          "Core sync can only be triggered in production. Use pnpm data-import to restore a snapshot locally.",
+      }
+      return
+    }
+
     const scope = ctx.request.body?.scope
     const incremental =
       ctx.request.body?.incremental !== undefined
@@ -34,6 +48,18 @@ export default ({ strapi }: { strapi: Core.Strapi }) => ({
   },
 
   async status(ctx: StrapiContext) {
-    ctx.body = getSyncStatus()
+    const status = getSyncStatus()
+    const isProduction = process.env.NODE_ENV === "production"
+
+    // When idle with no in-memory lastRun (e.g. after restart), enrich with
+    // persistent watermarks from the core_sync_states table so the UI always
+    // shows when the last sync ran and which phases were included.
+    if (!status.inProgress && !status.lastRun) {
+      const persisted = await getPersistedSyncStatus(strapi)
+      ctx.body = { ...status, ...persisted, isProduction }
+      return
+    }
+
+    ctx.body = { ...status, isProduction }
   },
 })
diff --git a/apps/cms/src/api/core-sync/services/core-sync.ts b/apps/cms/src/api/core-sync/services/core-sync.ts
index 0209c3e0..328b454f 100644
--- a/apps/cms/src/api/core-sync/services/core-sync.ts
+++ b/apps/cms/src/api/core-sync/services/core-sync.ts
@@ -7,6 +7,7 @@ import {
   ensureSyncStateTable,
   getLastSyncTime,
   setLastSyncTime,
+  getAllSyncTimes,
 } from "./strapi-helpers"
 import { syncLanguages } from "./sync-languages"
 import { syncCountries } from "./sync-countries"
@@ -74,6 +75,25 @@ export function getSyncStatus() {
   }
 }
 
+/**
+ * Read persistent sync state from the database for when in-memory state is
+ * empty (e.g. after server restart). Returns the most recent sync timestamp
+ * and per-phase watermarks so the admin UI can show "last synced at" even
+ * when the server has restarted since the last sync.
+ */
+export async function getPersistedSyncStatus(strapi: Core.Strapi) {
+  const phaseWatermarks = await getAllSyncTimes(strapi)
+
+  if (phaseWatermarks.length === 0) {
+    return { persistedLastRun: null, phaseWatermarks: [] }
+  }
+
+  // The most recent watermark across all phases is the last sync time
+  const persistedLastRun = phaseWatermarks[0].lastSyncedAt
+
+  return { persistedLastRun, phaseWatermarks }
+}
+
 /**
  * Resolve the requested scope into an ordered list of phases.
  * Accepts a single phase, an array of phases, or "all".
diff --git a/apps/cms/src/api/core-sync/services/strapi-helpers.ts b/apps/cms/src/api/core-sync/services/strapi-helpers.ts
index 9e7c6a7e..65e2d898 100644
--- a/apps/cms/src/api/core-sync/services/strapi-helpers.ts
+++ b/apps/cms/src/api/core-sync/services/strapi-helpers.ts
@@ -186,6 +186,25 @@ export async function getLastSyncTime(
   return val instanceof Date ? val.toISOString() : String(val)
 }
 
+/** Read the most recent sync timestamp across all phases (null = never synced). */
+export async function getAllSyncTimes(
+  strapi: Core.Strapi,
+): Promise<{ phase: string; lastSyncedAt: string }[]> {
+  const knex = strapi.db.connection
+  const exists = await knex.schema.hasTable(SYNC_STATE_TABLE)
+  if (!exists) return []
+  const rows = await knex(SYNC_STATE_TABLE)
+    .select("phase", "last_synced_at")
+    .orderBy("last_synced_at", "desc")
+  return rows.map((row: { phase: string; last_synced_at: Date | string }) => ({
+    phase: row.phase,
+    lastSyncedAt:
+      row.last_synced_at instanceof Date
+        ? row.last_synced_at.toISOString()
+        : String(row.last_synced_at),
+  }))
+}
+
 /** Persist the sync timestamp for a phase after a successful run. */
 export async function setLastSyncTime(
   strapi: Core.Strapi,
diff --git a/apps/cms/src/api/data-snapshot/controllers/data-snapshot.ts b/apps/cms/src/api/data-snapshot/controllers/data-snapshot.ts
index 94d30c81..fe2ab266 100644
--- a/apps/cms/src/api/data-snapshot/controllers/data-snapshot.ts
+++ b/apps/cms/src/api/data-snapshot/controllers/data-snapshot.ts
@@ -3,6 +3,8 @@ import {
   createSnapshot,
   getLatestDownloadUrl,
   getSnapshotStatus,
+  getPersistedSnapshotStatus,
+  getLocalImportStatus,
 } from "../services/data-snapshot"
 
 type StrapiContext = {
@@ -12,6 +14,15 @@ type StrapiContext = {
 
 export default ({ strapi }: { strapi: Core.Strapi }) => ({
   async trigger(ctx: StrapiContext) {
+    if (process.env.NODE_ENV !== "production") {
+      ctx.status = 403
+      ctx.body = {
+        error:
+          "Data snapshot can only be triggered in production. Use pnpm data-import to download a snapshot locally.",
+      }
+      return
+    }
+
     // Fire and forget — snapshot runs in background
     createSnapshot(strapi).catch((error) => {
       strapi.log.error(
@@ -42,6 +53,24 @@ export default ({ strapi }: { strapi: Core.Strapi }) => ({
   },
 
   async status(ctx: StrapiContext) {
-    ctx.body = getSnapshotStatus()
+    const status = getSnapshotStatus()
+    const isProduction = process.env.NODE_ENV === "production"
+
+    // When idle with no in-memory lastRun (e.g. after restart), enrich with
+    // persistent metadata from S3 so the UI always shows the latest snapshot info.
+    if (isProduction && !status.inProgress && !status.lastRun) {
+      const persisted = await getPersistedSnapshotStatus()
+      ctx.body = { ...status, ...persisted, isProduction }
+      return
+    }
+
+    // In non-production, include when the last local data-import was applied
+    if (!isProduction) {
+      const localImport = await getLocalImportStatus(strapi)
+      ctx.body = { ...status, localImport, isProduction }
+      return
+    }
+
+    ctx.body = { ...status, isProduction }
   },
 })
diff --git a/apps/cms/src/api/data-snapshot/services/data-snapshot.ts b/apps/cms/src/api/data-snapshot/services/data-snapshot.ts
index b3ca8e49..ac7e7e0d 100644
--- a/apps/cms/src/api/data-snapshot/services/data-snapshot.ts
+++ b/apps/cms/src/api/data-snapshot/services/data-snapshot.ts
@@ -92,6 +92,75 @@ async function enforceRetention(strapi: Core.Strapi): Promise<void> {
   }
 }
 
+/**
+ * Read local import status from the _data_imports table.
+ * Only meaningful in non-production environments where data-import is used.
+ */
+export async function getLocalImportStatus(strapi: Core.Strapi): Promise<{
+  lastImportedAt: string | null
+  snapshotKey: string | null
+}> {
+  try {
+    const knex = strapi.db.connection
+    const exists = await knex.schema.hasTable("_data_imports")
+    if (!exists) {
+      return { lastImportedAt: null, snapshotKey: null }
+    }
+
+    const row = await knex("_data_imports")
+      .select("snapshot_key", "applied_at")
+      .orderBy("applied_at", "desc")
+      .first()
+
+    if (!row) {
+      return { lastImportedAt: null, snapshotKey: null }
+    }
+
+    const appliedAt =
+      row.applied_at instanceof Date
+        ? row.applied_at.toISOString()
+        : String(row.applied_at)
+
+    return { lastImportedAt: appliedAt, snapshotKey: row.snapshot_key }
+  } catch {
+    return { lastImportedAt: null, snapshotKey: null }
+  }
+}
+
+/**
+ * Read persistent snapshot metadata from S3 when in-memory state is empty
+ * (e.g. after server restart). Returns the latest snapshot key, size, and
+ * last modified date so the admin UI can show snapshot info even after restart.
+ */
+export async function getPersistedSnapshotStatus(): Promise<{
+  persistedLastRun: string | null
+  latestSnapshot: {
+    key: string
+    lastModified: string
+    sizeBytes: number
+  } | null
+}> {
+  try {
+    const snapshots = await listSnapshots(BACKUP_PREFIX)
+    if (snapshots.length === 0) {
+      return { persistedLastRun: null, latestSnapshot: null }
+    }
+
+    const latest = snapshots[snapshots.length - 1]
+    return {
+      persistedLastRun: latest.lastModified.toISOString(),
+      latestSnapshot: {
+        key: latest.key,
+        lastModified: latest.lastModified.toISOString(),
+        sizeBytes: latest.sizeBytes,
+      },
+    }
+  } catch {
+    // S3 not configured or unreachable — no persistent data available
+    return { persistedLastRun: null, latestSnapshot: null }
+  }
+}
+
 export async function createSnapshot(
   strapi: Core.Strapi,
 ): Promise<SnapshotResult> {
diff --git a/apps/cms/src/api/data-snapshot/services/s3-client.ts b/apps/cms/src/api/data-snapshot/services/s3-client.ts
index 63e876c1..da103c3c 100644
--- a/apps/cms/src/api/data-snapshot/services/s3-client.ts
+++ b/apps/cms/src/api/data-snapshot/services/s3-client.ts
@@ -69,7 +69,7 @@ export async function getSnapshotPresignedUrl(
 
 export async function listSnapshots(
   prefix: string,
-): Promise<{ key: string; lastModified: Date }[]> {
+): Promise<{ key: string; lastModified: Date; sizeBytes: number }[]> {
   const s3 = getS3Client()
   const result = await s3.send(
     new ListObjectsV2Command({ Bucket: getBucket(), Prefix: prefix }),
@@ -77,7 +77,11 @@ export async function listSnapshots(
 
   return (result.Contents ?? [])
     .filter((obj) => obj.Key && obj.LastModified)
-    .map((obj) => ({ key: obj.Key!, lastModified: obj.LastModified! }))
+    .map((obj) => ({
+      key: obj.Key!,
+      lastModified: obj.LastModified!,
+      sizeBytes: obj.Size ?? 0,
+    }))
     .sort((a, b) => a.lastModified.getTime() - b.lastModified.getTime())
 }