Changeset 3705859

Timestamp:

09/21/2026 03:23:50 PM (4 weeks ago)

Author:

sitehale

Message:

SiteHale 0.7.66

Location:

sitehale/trunk

Files:

• changelog.txt (modified) (1 diff)
• includes/class-sitehale-seo-guard.php (modified) (3 diffs)
• includes/class-sitehale-seo-head.php (modified) (2 diffs)
• readme.txt (modified) (2 diffs)
• sitehale.php (modified) (2 diffs)

sitehale/trunk/changelog.txt

@@ -3 +3 @@
 readme.txt carries only recent releases: wp.org truncates a Changelog
 section past 5,000 words, silently, at import. This file is the full
-record, newest first (0.7.65 down to 0.1.0).
+record, newest first (0.7.66 down to 0.1.0).
+
+= 0.7.66 =
+* Fixes your pages' search-engine details going missing after a plugin change. Before SiteHale describes your pages to search engines, it checks that no other plugin is already doing so, and it repeats that check whenever the site changes. It re-ran the check by itself only after a SiteHale update. After you switched another plugin on or off, or when the check expired after 30 days, your pages had no custom titles, descriptions or social-sharing details until enough visitors had arrived to complete the check. On a quiet site that could take days. SiteHale now finishes the check itself as soon as it's needed. Sites where another plugin describes your pages, and sites that have SiteHale's search-engine features switched off, are unaffected.
 
 = 0.7.65 =

sitehale/trunk/includes/class-sitehale-seo-guard.php

@@ -300 +300 @@
                 // response has already gone to the browser so the loopbacks cost the
                 // visitor nothing.
+                self::schedule_warm();
+        }
+
+        /**
+         * Queue the warm loopbacks for this request's `shutdown`.
+         *
+         * The ONE place a warm is dispatched from, whichever event asked for it.
+         * Both callers need the same deferral (see above) and the same callback, and
+         * WordPress collapses an identical callback at an identical priority into a
+         * single registration, so a request that trips both triggers — a SiteHale
+         * update changes the fingerprint too — still sends one set of loopbacks.
+         */
+        private static function schedule_warm() {
                 if ( class_exists( 'SiteHale_SEO_Handover' ) ) {
                         add_action( 'shutdown', array( 'SiteHale_SEO_Handover', 'warm_guard' ), 5 );
+                }
+        }
+
+        /** Last dark-state warm: array( 'fp' => fingerprint, 'at' => unix time ). */
+        const OPT_LAST_REWARM = 'sitehale_seo_guard_rewarm';
+
+        /** Minimum gap between retries while the SAME dark state persists. */
+        const REWARM_RETRY = 21600; // 6 hours.
+
+        /**
+         * Whether a dark guard should send the warm loopbacks now. PURE.
+         *
+         * 🔴 THE VERSION TRIGGER ABOVE COVERED ONE CAUSE OF A DARK HEAD OUT OF FOUR.
+         * `is_fresh()` discards the evidence when the plugin set changes, when the
+         * theme changes, when our version changes, and when it is 30 days old. Only
+         * the third ever woke the module. Found 2026-09-21 retiring cognihance's
+         * store: deactivating nine WooCommerce plugins took the title, description,
+         * OpenGraph and JSON-LD off every page, and the guard read
+         * "evidence is stale — the plugin set, theme or plugin version changed".
+         * Nothing was going to bring them back but visitors, and nothing reads the
+         * rendered head to notice they were gone. The 30-day TTL does the same to
+         * EVERY client once a month, with nobody touching anything.
+         *
+         * So this keys on the STATE, not on a list of causes: an undecided guard is
+         * a dark head whatever made it undecided, and a cause nobody has thought of
+         * yet is covered without anyone having to think of it.
+         *
+         *   clear     never — the head is rendering.
+         *   conflict  never — dark ON PURPOSE; a rival owns the head, and warming
+         *             cannot change that (the fingerprint notices when it goes).
+         *   unknown   at once if the site has changed since the last warm, so a
+         *             deactivation is answered on the very next request; otherwise
+         *             no more often than REWARM_RETRY, so a site that can never
+         *             reach `clear` — a one-page site with no singular URL, a host
+         *             that refuses its own loopbacks — costs four loopbacks every
+         *             six hours rather than four on every page view.
+         *
+         * @param string $state       Guard verdict: clear|conflict|unknown.
+         * @param string $fingerprint The site's fingerprint now.
+         * @param mixed  $last        Stored OPT_LAST_REWARM value (any shape).
+         * @param int    $now         Unix time.
+         * @param int    $retry       Seconds between retries of an unchanged site.
+         * @return bool
+         */
+        public static function rewarm_due( $state, $fingerprint, $last, $now, $retry = self::REWARM_RETRY ) {
+                if ( 'unknown' !== $state ) {
+                        return false;
+                }
+                // Malformed or absent history is "never warmed", not a reason to wait.
+                if ( ! is_array( $last ) || ! isset( $last['fp'], $last['at'] ) ) {
+                        return true;
+                }
+                if ( (string) $last['fp'] !== (string) $fingerprint ) {
+                        return true;
+                }
+                return ( (int) $now - (int) $last['at'] ) >= (int) $retry;
+        }
+
+        /**
+         * Send the warm loopbacks when the guard is undecided. See rewarm_due().
+         *
+         * ⚠️ NEVER UNDER WP-CLI. `--skip-plugins` and `--skip-themes` filter
+         * `active_plugins` and `stylesheet` inside the CLI process, so the
+         * fingerprint a CLI command computes is not the site's. Recording it would
+         * flip-flop against every web request — and this repo's own automation
+         * passes skip flags — firing a spurious warm on both sides of each CLI call,
+         * and a read-only command such as `plugin list` would start writing options.
+         * A change made FROM the CLI is still answered: the next web request sees
+         * the fingerprint it did not record and warms from there.
+         *
+         * ⚠️ WRITTEN BEFORE DISPATCH, for the same reason as the version option: the
+         * loopbacks are themselves requests to this site, still undecided, and they
+         * must find this warm already recorded or each would dispatch another.
+         */
+        private static function maybe_rewarm_when_dark() {
+                if ( defined( 'WP_CLI' ) && WP_CLI ) {
+                        return;
+                }
+                // Only where a head is WANTED: warming a site that renders nothing by
+                // design restores nothing. See SiteHale_SEO_Head::wants_render().
+                if ( ! class_exists( 'SiteHale_SEO_Head' ) || ! SiteHale_SEO_Head::wants_render() ) {
+                        return;
+                }
+                $state = self::state();
+                if ( 'unknown' !== $state['state'] ) {
+                        return; // The common case costs no query beyond the verdict itself.
+                }
+                $fp   = self::fingerprint();
+                $now  = time();
+                $last = get_option( self::OPT_LAST_REWARM, array() );
+                if ( ! self::rewarm_due( $state['state'], $fp, $last, $now ) ) {
+                        return;
+                }
+                update_option( self::OPT_LAST_REWARM, array( 'fp' => $fp, 'at' => $now ), false );
+                self::schedule_warm();
+        }
+
+        /**
+         * A decided verdict ends the dark episode, so it ends the warm history.
+         *
+         * Called from store(), the one place evidence is written — which only runs
+         * while the guard is still observing, so this costs nothing on a site that
+         * is simply rendering. It reads the verdict to decide; it never persists
+         * one (the stored record stays evidence, not a conclusion).
+         *
+         * ⚠️ rewarm_due() waits out REWARM_RETRY when the fingerprint matches the
+         * last warm — right within ONE episode, wrong across two. Measured on the
+         * testbox 2026-09-21: a plugin activated then deactivated returns the site
+         * to the fingerprint of a warm from twenty minutes earlier, the evidence
+         * was discarded in between, and the head stayed dark with the retry window
+         * reading "already tried". Plugin off, plugin back on is the most ordinary
+         * troubleshooting there is. Clearing here means every new episode warms at
+         * once, whatever caused it. `conflict` counts as decided too: a rival
+         * toggled on and back off is the same trap from the other side.
+         *
+         * @param array $rec The evidence record just written.
+         */
+        private static function end_episode_if_decided( $rec ) {
+                $decided = self::verdict(
+                        isset( $rec['contexts'] ) ? $rec['contexts'] : array(),
+                        isset( $rec['rival'] ) ? $rec['rival'] : ''
+                );
+                if ( 'unknown' !== $decided['state'] ) {
+                        delete_option( self::OPT_LAST_REWARM );
                 }
         }
@@ -310 +447 @@
                 }
                 self::maybe_reobserve_after_update();
+                self::maybe_rewarm_when_dark();
                 // Outside every other emitter. `sitehale-term-seo.php` opens its own
                 // buffer at priority 1 and closes it at 999; ours must enclose that
@@ -725 +863 @@
                 // belongs in the autoload cache.
                 update_option( self::OPTION, $rec, true );
+
+                // Ends the dark episode's warm history once the evidence decides.
+                self::end_episode_if_decided( $rec );
         }
 }

sitehale/trunk/includes/class-sitehale-seo-head.php

@@ -165 +165 @@
                         return false;
                 }
-                $opts = get_option( SiteHale_SEO_Store::OPTION, array() );
-                // An explicit stored value always wins, in both directions. Absent, the
-                // default depends on who is running this site — see renders_by_default().
-                $on = isset( $opts['render'] ) ? (bool) $opts['render'] : self::renders_by_default();
+                $on = self::wants_render();
                 if ( $on && ! SiteHale_SEO_Guard::clear() ) {
                         $on = false;
@@ -178 +175 @@
                  */
                 return (bool) apply_filters( 'sitehale_seo_render', $on );
+        }
+
+        /**
+         * Whether this site WANTS its head rendered, before the guard has its say.
+         *
+         * Split out of should_render() so the guard can ask it: a dark guard is only
+         * worth waking on a site that would render once it is clear. A free
+         * wordpress.org install renders nothing by design, so there is no head to
+         * restore and its footprint stays what it was — a warm on update, no more.
+         *
+         * @return bool
+         */
+        public static function wants_render() {
+                if ( ! SiteHale_SEO_Store::enabled() ) {
+                        return false;
+                }
+                $opts = get_option( SiteHale_SEO_Store::OPTION, array() );
+                // An explicit stored value always wins, in both directions. Absent, the
+                // default depends on who is running this site — see renders_by_default().
+                return isset( $opts['render'] ) ? (bool) $opts['render'] : self::renders_by_default();
         }
 

sitehale/trunk/readme.txt

@@ -5 +5 @@
 Tested up to: 7.1
 Requires PHP: 7.4
-Stable tag: 0.7.65
+Stable tag: 0.7.66
 License: GPLv2 or later
 License URI: https://www.gnu.org/licenses/gpl-2.0.html
@@ -195 +195 @@
 == Changelog ==
 
+= 0.7.66 =
+* Fixes your pages' search-engine details going missing after a plugin change. Before SiteHale describes your pages to search engines, it checks that no other plugin is already doing so, and it repeats that check whenever the site changes. It re-ran the check by itself only after a SiteHale update. After you switched another plugin on or off, or when the check expired after 30 days, your pages had no custom titles, descriptions or social-sharing details until enough visitors had arrived to complete the check. On a quiet site that could take days. SiteHale now finishes the check itself as soon as it's needed. Sites where another plugin describes your pages, and sites that have SiteHale's search-engine features switched off, are unaffected.
+
 = 0.7.65 =
 * Keeps your RSS feeds out of Google's index again. The SEO plugin SiteHale replaced told search engines not to index feeds, and SiteHale did not carry that over. Every post and product has its own comments feed, so Google began finding feed copies of your pages and reporting them in Search Console as "Duplicate without user-selected canonical". SiteHale now sends the same noindex instruction on every feed that the previous plugin did. Your pages, and the feeds themselves, are unchanged for readers and feed apps.

sitehale/trunk/sitehale.php

@@ -4 +4 @@
  * Plugin URI:        https://sitehale.com/how-it-works/
  * Description:       Free Site Checkup (cron, PHP errors, database, updates, admins, SEO basics, disk, mail) plus the companion to the SiteHale managed care service. Sends nothing anywhere until you click Connect.
- * Version:           0.7.65
+ * Version:           0.7.66
  * Requires at least: 5.7
  * Requires PHP:      7.4
@@ -30 +30 @@
 }
 
-define( 'SITEHALE_VERSION', '0.7.65' );
+define( 'SITEHALE_VERSION', '0.7.66' );
 define( 'SITEHALE_PLUGIN_FILE', __FILE__ );
 define( 'SITEHALE_PLUGIN_DIR', plugin_dir_path( __FILE__ ) );