@adhdev/daemon-standalone 1.0.41-rc.7 → 1.0.41-rc.8

package/dist/index.js

@@ -36556,10 +36556,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "95386596964cf9654126f78b31c6f7a917789dda" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "95386596" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.41-rc.7" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-09T16:45:57.944Z" : void 0);
+      const commit = readInjected(true ? "e76abaa7f3aa697fff411260da07b222bbc57117" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "e76abaa7" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.41-rc.8" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-09T23:59:15.763Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -91617,7 +91617,13 @@ ${marker}`,
           version: ctx.deps.statusVersion || "unknown",
           profile: "metadata"
         });
-        return { success: true, status: snapshot, daemonBuild: getDaemonBuildInfo(), upgradeFailure: readUpgradeFailureNotice() };
+        return {
+          success: true,
+          status: snapshot,
+          daemonBuild: getDaemonBuildInfo(),
+          upgradeFailure: readUpgradeFailureNotice(),
+          providerChannelStaleness: ctx.deps.providerLoader?.getChannelStalenessSnapshot?.() ?? null
+        };
       },
       get_machine_runtime_stats: async (_ctx, _args) => {
         const quota = readQuotaCache();
@@ -105701,6 +105707,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
       allowUnverifiedTarball;
       channelStore;
       channelSyncIO;
+      /** Running daemon version (normalized, no leading 'v'); '' when unknown. */
+      daemonVersion = "";
+      /** Last read-only staleness probe result (checkVerifiedChannelStaleness). */
+      channelStalenessSnapshot = null;
       probeStarts = [];
       siblingLogged = false;
       /** Active verified-channel object dirs, refreshed by loadAll(). */
@@ -105795,6 +105805,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.allowUnverifiedTarball = options?.allowUnverifiedTarball === true || process.env[_ProviderLoader.UNVERIFIED_TARBALL_ENV_VAR] === "1";
         this.channelStore = options?.channelStore === null ? null : options?.channelStore ?? new ProviderChannelStore(ProviderChannelStore.defaultRoot(), this.logFn);
         this.channelSyncIO = options?.channelSyncIO;
+        this.daemonVersion = (options?.daemonVersion || "").trim().replace(/^v/, "");
         this.defaultProvidersDir = path45.join(getConfigDir2(), "providers");
         const detected = this.detectDefaultUserDir();
         this.userDir = detected.path;
@@ -106081,6 +106092,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (report.activated.length > 0) {
           this.loadAll();
         }
+        if (report.status !== "error") {
+          this.writeChannelActivationStamp();
+        }
         return report;
       }
       /**
@@ -106128,6 +106142,122 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         return this.syncVerifiedChannel({ bootstrapAll: true });
       }
+      /** Stamp path recording which daemon version last ran a successful verified sync. */
+      channelActivationStampPath() {
+        return path45.join(this.defaultProvidersDir, ".channel-activation-stamp.json");
+      }
+      readChannelActivationStamp() {
+        try {
+          return JSON.parse(fs41.readFileSync(this.channelActivationStampPath(), "utf-8"));
+        } catch {
+          return null;
+        }
+      }
+      writeChannelActivationStamp() {
+        if (!this.daemonVersion) return;
+        try {
+          fs41.mkdirSync(this.defaultProvidersDir, { recursive: true });
+          fs41.writeFileSync(this.channelActivationStampPath(), JSON.stringify({
+            daemonVersion: this.daemonVersion,
+            channel: this.channel,
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }, null, 2));
+        } catch {
+        }
+      }
+      /**
+       * DAEMON-UPDATE = PROVIDER ACTIVATION (owner decision 2026-08-10, option C).
+       *
+       * The verified-channel pin deliberately only advances on an explicit
+       * activation ("the user saying now"), which left published provider fixes
+       * invisible on every machine where nobody pressed the button — live 08-10
+       * measurement: every fleet pin still carried the 08-07 bootstrap timestamp
+       * after a publish AND a full fleet restart. The daemon upgrade is the one
+       * update moment the user already trusts, so ride it: on the FIRST boot of a
+       * new daemon version (or after a channel switch), run one full verified
+       * sync. Every other boot stays network-free — the stamp written by the last
+       * successful sync short-circuits same-version boots. Fail-closed: an
+       * errored sync writes no stamp, so the next boot retries; last-known-good
+       * activations are untouched throughout (syncVerifiedChannel semantics).
+       *
+       * Empty stores are excluded — maybeFirstSyncVerifiedChannel owns bootstrap,
+       * and its successful sync writes the same stamp (both paths converge in
+       * syncVerifiedChannel), so a fresh install does not double-sync.
+       *
+       * Note this advances EXISTING targets (active pins + installed set) only. A
+       * provider type first published after bootstrap still needs an explicit
+       * catalog install — surfaced by checkVerifiedChannelStaleness as newTypes.
+       */
+      async maybeSyncVerifiedChannelOnDaemonUpdate() {
+        if (!this.channelStore || !this.daemonVersion) return null;
+        if (this.countVerifiedChannelPointers() === 0) return null;
+        const stamp = this.readChannelActivationStamp();
+        if (stamp?.daemonVersion === this.daemonVersion && stamp?.channel === this.channel) return null;
+        this.log(`Daemon version transition detected (stamp=${stamp?.daemonVersion ?? "none"}@${stamp?.channel ?? "-"} \u2192 ${this.daemonVersion}@${this.channel}) \u2014 running verified channel sync`);
+        return this.syncVerifiedChannel();
+      }
+      /**
+       * Read-only staleness probe (owner decision 2026-08-10, option A).
+       *
+       * ONE channel-listing request, no downloads, no pointer writes: compares the
+       * channel's current entries against the local active pins and reports
+       *   - staleTypes: pinned providers whose channel entry moved past the pin
+       *   - newTypes:   activatable channel entries this machine has never
+       *                 activated NOR installed — the class that made kimi
+       *                 invisible (published after bootstrap, unreachable even by
+       *                 activate_provider_updates because the sync target set is
+       *                 pins+installed).
+       * The result is cached on the loader for get_status_metadata so dashboards
+       * can badge without triggering network from a status path. Fail-closed: on
+       * any transport/shape error the previous snapshot is kept and the error is
+       * recorded on it.
+       */
+      async checkVerifiedChannelStaleness() {
+        const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (!this.channelStore) {
+          return this.channelStalenessSnapshot = { checkedAt, channel: this.channel, staleTypes: [], newTypes: [], error: "verified channel store is disabled" };
+        }
+        const runtime = new ProviderChannelRuntime({
+          store: this.channelStore,
+          registryBaseUrl: this.registryBaseUrl,
+          providerTarballUrl: this.providerTarballUrl,
+          logFn: this.logFn,
+          ...this.channelSyncIO
+        });
+        let entries;
+        try {
+          entries = await runtime.fetchChannelEntries(this.channel);
+        } catch (e) {
+          const prev = this.channelStalenessSnapshot;
+          return this.channelStalenessSnapshot = {
+            checkedAt,
+            channel: this.channel,
+            staleTypes: prev?.staleTypes ?? [],
+            newTypes: prev?.newTypes ?? [],
+            error: e?.message || String(e)
+          };
+        }
+        const pins = this.listVerifiedChannelPins();
+        const installedTargets = collectSyncTargetTypes(this.upstreamDir, this.channelStore, this.channel);
+        const staleTypes = [];
+        const newTypes = [];
+        for (const entry of entries) {
+          if (!entry.bundleDigest) continue;
+          const pin = pins.get(entry.providerType);
+          if (pin) {
+            if (pin.active?.digest !== entry.bundleDigest) staleTypes.push(entry.providerType);
+          } else if (!installedTargets.has(entry.providerType)) {
+            newTypes.push(entry.providerType);
+          }
+        }
+        staleTypes.sort();
+        newTypes.sort();
+        return this.channelStalenessSnapshot = { checkedAt, channel: this.channel, staleTypes, newTypes };
+      }
+      /** Last probe result (null until the first checkVerifiedChannelStaleness run). Pure read. */
+      getChannelStalenessSnapshot() {
+        return this.channelStalenessSnapshot;
+      }
       /**
        * The verified-channel PIN for each provider: what this daemon actually
        * loads, as opposed to what is sitting in `.upstream`.
@@ -125189,12 +125319,16 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         providerTarballUrl: appConfig.providerTarballUrl,
         channel: appConfig.providerChannel,
         updateChannel: appConfig.updateChannel,
-        allowUnverifiedTarball: appConfig.providerAllowUnverifiedTarball
+        allowUnverifiedTarball: appConfig.providerAllowUnverifiedTarball,
+        // Enables the daemon-update = provider-activation stamp (option C):
+        // a boot on a NEW daemon version runs one verified sync; same-version
+        // boots stay network-free.
+        daemonVersion: config2.statusVersion
       });
       providerLoader.loadAll();
       providerLoader.registerToDetector();
       void providerLoader.maybeFirstSyncVerifiedChannel().then(async (report) => {
-        if (!report) return;
+        if (!report) return null;
         if (report.status === "error") {
           LOG2.warn("Init", `Verified channel first-sync failed (last-known-good preserved): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
         } else if (report.activated.length > 0) {
@@ -125203,7 +125337,47 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
           await refreshProviderAvailability();
           config2.onStatusChange?.();
         }
-      }).catch((e) => LOG2.warn("Init", `Verified channel first-sync error: ${e?.message || e}`));
+        return report;
+      }).then(async (firstSyncReport) => {
+        if (firstSyncReport) return;
+        const report = await providerLoader.maybeSyncVerifiedChannelOnDaemonUpdate();
+        if (!report) return;
+        if (report.status === "error") {
+          LOG2.warn("Init", `Daemon-update channel sync failed (last-known-good preserved, retries next boot): ${report.errors.map((e) => e.code).join(", ") || "unknown"}`);
+        } else if (report.activated.length > 0) {
+          LOG2.info("Init", `Daemon-update channel sync activated ${report.activated.length} providers (${providerLoader.channel})`);
+          providerLoader.registerToDetector();
+          await refreshProviderAvailability();
+          config2.onStatusChange?.();
+        }
+      }).catch((e) => LOG2.warn("Init", `Verified channel boot sync error: ${e?.message || e}`));
+      const runStalenessProbe = async () => {
+        try {
+          const snap = await providerLoader.checkVerifiedChannelStaleness();
+          if (snap.error) {
+            LOG2.debug("Provider", `Channel staleness probe failed (kept previous snapshot): ${snap.error}`);
+          } else if (snap.staleTypes.length > 0 || snap.newTypes.length > 0) {
+            LOG2.info("Provider", `Channel staleness: ${snap.staleTypes.length} stale [${snap.staleTypes.join(", ")}], ${snap.newTypes.length} never-installed [${snap.newTypes.join(", ")}] (${snap.channel})`);
+            config2.onStatusChange?.();
+          }
+        } catch (e) {
+          LOG2.debug("Provider", `Channel staleness probe error: ${e?.message || e}`);
+        }
+      };
+      const stalenessInitialTimer = setTimeout(() => {
+        void runStalenessProbe();
+      }, 10 * 6e4);
+      stalenessInitialTimer.unref?.();
+      const stalenessIntervalTimer = setInterval(() => {
+        void runStalenessProbe();
+      }, 24 * 60 * 6e4);
+      stalenessIntervalTimer.unref?.();
+      const providerStalenessProbe = {
+        stop() {
+          clearTimeout(stalenessInitialTimer);
+          clearInterval(stalenessIntervalTimer);
+        }
+      };
       setDefaultProviderLoader(providerLoader);
       const versionArchive = new VersionArchive();
       providerLoader.setVersionArchive(versionArchive);
@@ -125396,6 +125570,7 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
       components.meshReconcileLoop = setupMeshReconcileLoop(components);
       components.quotaRefreshLoop = setupQuotaRefreshLoop(components);
       components.quotaEventRefresh = setupQuotaEventRefresh(components);
+      components.providerStalenessProbe = providerStalenessProbe;
       setImmediate(() => {
         const isQuotaProviderEnabled = quotaProviderEnabledFromLoader(components.providerLoader);
         try {
@@ -125433,7 +125608,8 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         cdpManagers,
         meshReconcileLoop,
         quotaRefreshLoop,
-        quotaEventRefresh
+        quotaEventRefresh,
+        providerStalenessProbe
       } = components;
       poller.stop();
       cdpInitializer.stop();
@@ -125449,6 +125625,10 @@ ${upgradeFailureNotice.notice}${supersededHint}`);
         quotaEventRefresh?.stop();
       } catch {
       }
+      try {
+        providerStalenessProbe?.stop();
+      } catch {
+      }
       try {
         if (agentStreamManager) {
           await agentStreamManager.dispose(cdpManagers);