oysterun 1.6.0-beta.2 → 1.6.0-beta.21

package/host-service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oysterun-host-service",
-  "version": "1.6.0-beta.2",
+  "version": "1.6.0-beta.21",
   "type": "module",
   "description": "Oysterun host service — runs on Mac mini, manages Claude Code sessions",
   "scripts": {
@@ -45,6 +45,7 @@
     "test:p118": "node test-p118-exact-matrix-event-context.mjs",
     "test:p119": "node test-p119-telegram-multi-chat-origin-routing.mjs",
     "test:p208": "node --test test-p208-reasoning-effort-configuration-precedence.mjs",
+    "test:p220": "node test-p220-session-tags.mjs && node test-p220-session-tags-lifecycle.mjs",
     "test:p226": "node --test test-p226-lifecycle-diagnostics.mjs test-p226-service-definition-migration.mjs"
   },
   "dependencies": {

package/host-service/portable-scheduler-definitions.mjs

@@ -16,6 +16,7 @@ import {
   getHostSystemTimezone,
   normalizeScheduleRule,
 } from "./scheduler-rule-model.mjs";
+import { resolveSchedulerRunTimeout } from "./scheduler-run-timeout-policy.mjs";
 
 export const PORTABLE_SCHEDULER_STORAGE_OWNER =
   "agent_folder_oysterun_schedulers_json";
@@ -200,6 +201,14 @@ function normalizePortableScheduleForFile(input, { now, agentFolder }) {
   const metadata = isObjectRecord(input.metadata)
     ? normalizePortableMetadata(input.metadata)
     : {};
+  const timeoutPresent = Object.prototype.hasOwnProperty.call(
+    input,
+    "run_timeout_seconds"
+  );
+  const timeout = resolveSchedulerRunTimeout(input.run_timeout_seconds, {
+    present: timeoutPresent,
+    source: normalizeOptionalString(input.run_timeout_source),
+  });
   return {
     id,
     agent_id: projectId,
@@ -217,6 +226,12 @@ function normalizePortableScheduleForFile(input, { now, agentFolder }) {
     setup_snapshot: setupSnapshot,
     portable_setup_snapshot: portableSetupSnapshot,
     metadata,
+    ...(timeoutPresent
+      ? {
+          run_timeout_seconds: timeout.seconds,
+          run_timeout_source: timeout.source,
+        }
+      : {}),
     created_at: createdAt,
     updated_at: normalizeOptionalString(input.updated_at) || now,
     storage_owner: PORTABLE_SCHEDULER_STORAGE_OWNER,
@@ -772,6 +787,16 @@ export class PortableSchedulerDefinitionStore {
     const validationFailed =
       definition.metadata?.portable_scheduler_validation_failed === true;
     const effectiveEnabled = definition.enabled === true;
+    const runTimeout = resolveSchedulerRunTimeout(
+      definition.run_timeout_seconds,
+      {
+        present: Object.prototype.hasOwnProperty.call(
+          definition,
+          "run_timeout_seconds"
+        ),
+        source: definition.run_timeout_source,
+      }
+    );
     const normalizedRule =
       validationFailed && !isObjectRecord(definition.schedule_rule)
         ? null
@@ -815,6 +840,9 @@ export class PortableSchedulerDefinitionStore {
       next_run_at: nextRunAt,
       availability_state: availabilityState,
       availability_reason: availabilityReason,
+      run_timeout_seconds: runTimeout.seconds,
+      run_timeout_source: runTimeout.source,
+      run_timeout_explicit: runTimeout.explicit,
       metadata: {
         ...definition.metadata,
         source: "browser_root_project_schedulers_json",

package/host-service/product-runtime-host-origin.mjs

@@ -0,0 +1,22 @@
+function normalizeOrigin(value) {
+  return typeof value === "string" ? value.trim().replace(/\/+$/, "") : "";
+}
+
+export function resolveProductRuntimeHostOrigin({
+  config,
+  directHostUrl,
+  port,
+}) {
+  if (config?.connection_mode === "cloud") {
+    return normalizeOrigin(config.managed_endpoint) || `http://127.0.0.1:${port}`;
+  }
+  if (config?.connection_mode === "direct") {
+    return (
+      normalizeOrigin(directHostUrl) ||
+      normalizeOrigin(config.direct_host_url) ||
+      normalizeOrigin(config.public_base_url) ||
+      `http://127.0.0.1:${port}`
+    );
+  }
+  return `http://127.0.0.1:${port}`;
+}

package/host-service/provider-model-params.mjs

@@ -431,25 +431,10 @@ function statusTimestamp(params, providerId) {
     normalizeString(providerModels.refreshed_at) ||
     normalizeString(providerModels.last_success_at) ||
     normalizeString(providerRuntime.last_success_at) ||
-    normalizeString(providerRuntime.last_attempt_at) ||
-    normalizeString(params.refresh?.last_success_at) ||
     null
   );
 }
 
-function parseStatusTimestamp(value) {
-  const normalized = normalizeString(value);
-  if (!normalized) return null;
-  const ms = Date.parse(normalized);
-  return Number.isFinite(ms) ? ms : null;
-}
-
-function nextProviderRefreshAt(params, providerId) {
-  const refreshedAtMs = parseStatusTimestamp(statusTimestamp(params, providerId));
-  if (!refreshedAtMs) return null;
-  return new Date(refreshedAtMs + PROVIDER_MODEL_REFRESH_INTERVAL_MS).toISOString();
-}
-
 export function loadProviderModelCatalogState(providerId, options = {}) {
   if (
     providerId === "debug-fixture" ||
@@ -500,10 +485,22 @@ export function loadProviderModelCatalogState(providerId, options = {}) {
           normalizeString(providerRuntime?.last_error) ||
           null,
         refreshed_at: statusTimestamp(result.params, providerId),
+        last_success_at: statusTimestamp(result.params, providerId),
+        last_attempt_at: normalizeString(providerRuntime.last_attempt_at),
+        last_attempt_source: normalizeString(providerRuntime.last_attempt_source),
+        last_attempt_status: normalizeString(providerRuntime.probe_status),
+        process_cleanup: cloneValue(providerRuntime.process_cleanup || null),
+        last_attempt_reason: [
+          normalizeString(providerRuntime.refresh_skip_reason) || normalizeString(providerRuntime.last_error),
+          ["unknown", "failed"].includes(providerRuntime.process_cleanup?.status)
+            ? `Process cleanup ${providerRuntime.process_cleanup.status}: owned descendant absence is not confirmed.`
+            : null,
+        ].filter(Boolean).join(" ") || null,
+        using_previous_catalog: models.length > 0 && ["error", "skipped"].includes(providerRuntime.probe_status),
         next_refresh_at:
-          nextProviderRefreshAt(result.params, providerId) ||
           normalizeString(result.params.refresh?.next_refresh_at),
-        refresh_scheduling_authority: "provider_last_refresh_plus_interval",
+        refresh_scheduling_authority: result.params.refresh?.scheduling_authority || null,
+        refresh_time_zone: result.params.refresh?.time_zone || null,
         runtime: cloneValue(providerRuntime),
       },
     };

package/host-service/provider-model-refresh-runner.mjs

@@ -1,3 +1,8 @@
+import {
+  nextProviderModelRefreshTime,
+  providerModelRefreshZone,
+  PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY,
+} from "./provider-model-refresh-schedule.mjs";
 import { appendFileSync, mkdirSync } from "fs";
 import { dirname, join } from "path";
 import {
@@ -9,7 +14,6 @@ import { getConfigDir, readConfig } from "./config.mjs";
 import { discoverCodexProviderModels } from "./codex-model-discovery.mjs";
 import { discoverGrokProviderModels } from "./grok-acp-model-discovery.mjs";
 import {
-  PROVIDER_MODEL_REFRESH_INTERVAL_MS,
   readProviderModelParams,
   writeProviderModelParams,
 } from "./provider-model-params.mjs";
@@ -20,7 +24,6 @@ import {
   requireProvider,
 } from "./provider-registry.mjs";
 
-const DEFAULT_STARTUP_DELAY_MS = 5 * 60 * 1000;
 const MAX_ERROR_LENGTH = 500;
 const PROVIDER_MODEL_REFRESH_OPERATION_LOG_NAME =
   "provider_model_refresh.jsonl";
@@ -67,12 +70,6 @@ function appendProviderModelRefreshOperationLog(row, options = {}) {
   return logPath;
 }
 
-function parseTime(value) {
-  if (typeof value !== "string" || !value.trim()) return null;
-  const ms = Date.parse(value);
-  return Number.isFinite(ms) ? ms : null;
-}
-
 function normalizeRefreshProviderId(providerId) {
   if (providerId === undefined || providerId === null) return null;
   const normalized = String(providerId).trim().toLowerCase();
@@ -82,29 +79,6 @@ function normalizeRefreshProviderId(providerId) {
   return normalized;
 }
 
-function providerRefreshTimestamp(params, providerId) {
-  const providerModels = params?.provider_models?.[providerId] || {};
-  const providerRuntime = params?.provider_runtime?.[providerId] || {};
-  return (
-    parseTime(providerModels.refreshed_at) ||
-    parseTime(providerModels.last_success_at) ||
-    parseTime(providerRuntime.last_success_at) ||
-    parseTime(providerRuntime.last_attempt_at) ||
-    null
-  );
-}
-
-function providerNextRefreshAt(params, providerId, refreshIntervalMs) {
-  const lastRefreshMs = providerRefreshTimestamp(params, providerId);
-  if (!lastRefreshMs) return null;
-  return new Date(lastRefreshMs + refreshIntervalMs).toISOString();
-}
-
-function isProviderRefreshDue(params, providerId, nowMs, refreshIntervalMs) {
-  const lastRefreshMs = providerRefreshTimestamp(params, providerId);
-  return !lastRefreshMs || nowMs - lastRefreshMs >= refreshIntervalMs;
-}
-
 export class ProviderModelRefreshRunner {
   constructor(options = {}) {
     this.configDir = options.configDir || null;
@@ -143,20 +117,18 @@ export class ProviderModelRefreshRunner {
     this.setTimeoutFn = options.setTimeoutFn || setTimeout;
     this.clearTimeoutFn = options.clearTimeoutFn || clearTimeout;
     this.nowFn = options.nowFn || Date.now;
-    this.startupDelayMs = Number.isInteger(options.startupDelayMs)
-      ? options.startupDelayMs
-      : DEFAULT_STARTUP_DELAY_MS;
-    this.refreshIntervalMs = Number.isInteger(options.refreshIntervalMs)
-      ? options.refreshIntervalMs
-      : PROVIDER_MODEL_REFRESH_INTERVAL_MS;
     this.logger = options.logger || console;
     this.timer = null;
     this.started = false;
-    this.running = false;
+    this.activeProviders = new Set();
+    this.nextRefreshAt = null;
+    this.scheduleZone = providerModelRefreshZone();
+    this.clockTimer = null;
   }
 
   start() {
     if (!this.backgroundRefreshEnabled) {
+      this.persistSchedule();
       return {
         status: "disabled",
         reason: this.backgroundRefreshDisabledReason,
@@ -167,103 +139,60 @@ export class ProviderModelRefreshRunner {
       return { status: "already_started" };
     }
     this.started = true;
-    this.scheduleNext({ startup: true });
+    this.scheduleNext();
+    this.watchClock();
     return { status: "started" };
   }
 
   stop() {
     this.started = false;
+    if (this.clockTimer) this.clearTimeoutFn(this.clockTimer);
+    this.clockTimer = null;
+    this.nextRefreshAt = null;
+    this.persistSchedule();
     if (this.timer) {
       this.clearTimeoutFn(this.timer);
       this.timer = null;
     }
   }
 
-  computeNextDelay({ startup = false } = {}) {
-    if (startup) {
-      return Math.max(0, this.startupDelayMs);
-    }
-    try {
-      const result = this.readParamsFn({ configDir: this.configDir });
-      const nowMs = this.nowFn();
-      const nextRefreshTimes = PRODUCT_PROVIDER_REFRESH_IDS.map((providerId) =>
-        providerRefreshTimestamp(result.params, providerId)
-      )
-        .filter((timeMs) => Number.isFinite(timeMs))
-        .map((timeMs) => timeMs + this.refreshIntervalMs);
-      if (nextRefreshTimes.length < PRODUCT_PROVIDER_REFRESH_IDS.length) {
-        return 0;
-      }
-      const dueNow = nextRefreshTimes.some((timeMs) => timeMs <= nowMs);
-      if (dueNow) return 0;
-      return Math.max(0, Math.min(...nextRefreshTimes) - nowMs);
-    } catch {
-      // Bad params should not create a timer storm; use the normal interval.
-    }
-    return Math.max(0, this.refreshIntervalMs);
+  computeNextDelay() {
+    const now = this.nowFn();
+    return nextProviderModelRefreshTime(now) - now;
   }
 
   getProviderRefreshStatus(providerId) {
     const provider = normalizeRefreshProviderId(providerId);
-    const result = this.readParamsFn({ configDir: this.configDir });
-    const refreshedAtMs = providerRefreshTimestamp(result.params, provider);
+    const { params } = this.readParamsFn({ configDir: this.configDir });
+    const runtime = params.provider_runtime?.[provider] || {};
     return {
       provider,
-      refreshed_at: refreshedAtMs
-        ? new Date(refreshedAtMs).toISOString()
-        : null,
-      next_refresh_at: providerNextRefreshAt(
-        result.params,
-        provider,
-        this.refreshIntervalMs
-      ),
-      refresh_due:
-        isProviderRefreshDue(
-          result.params,
-          provider,
-          this.nowFn(),
-          this.refreshIntervalMs
-        ) === true,
-      scheduling_authority: "provider_last_refresh_plus_interval",
+      refreshed_at: params.provider_models?.[provider]?.refreshed_at || runtime.last_success_at || null,
+      last_attempt_at: runtime.last_attempt_at || null,
+      last_attempt_source: runtime.last_attempt_source || null,
+      last_attempt_status: runtime.probe_status || null,
+      process_cleanup: runtime.process_cleanup || null,
+      next_refresh_at: this.nextRefreshAt,
+      refresh_due: this.nextRefreshAt ? Date.parse(this.nextRefreshAt) <= this.nowFn() : false,
+      scheduling_authority: PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY,
     };
   }
 
   getAllProviderRefreshStatus() {
-    try {
-      return PRODUCT_PROVIDER_REFRESH_IDS.map((providerId) =>
-        this.getProviderRefreshStatus(providerId)
-      );
-    } catch {
-      return PRODUCT_PROVIDER_REFRESH_IDS.map((providerId) => ({
-        provider: providerId,
-        refreshed_at: null,
-        next_refresh_at: null,
-        refresh_due: true,
-        scheduling_authority: "provider_last_refresh_plus_interval",
-      }));
-    }
+    return PRODUCT_PROVIDER_REFRESH_IDS.map((providerId) => this.getProviderRefreshStatus(providerId));
   }
 
-  getTargetProviderIds({ provider = null, force = true } = {}) {
+  getTargetProviderIds({ provider = null } = {}) {
     const normalizedProvider = normalizeRefreshProviderId(provider);
-    const providerIds = normalizedProvider
-      ? [normalizedProvider]
-      : [...PRODUCT_PROVIDER_REFRESH_IDS];
-    if (force) return providerIds;
-    try {
-      const result = this.readParamsFn({ configDir: this.configDir });
-      const nowMs = this.nowFn();
-      return providerIds.filter((providerId) =>
-        isProviderRefreshDue(
-          result.params,
-          providerId,
-          nowMs,
-          this.refreshIntervalMs
-        )
-      );
-    } catch {
-      return providerIds;
-    }
+    return normalizedProvider ? [normalizedProvider] : [...PRODUCT_PROVIDER_REFRESH_IDS];
+  }
+
+  persistSchedule() {
+    this.writeParamsFn({ refresh: {
+      next_refresh_at: this.nextRefreshAt,
+      scheduling_authority: PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY,
+      time_zone: this.scheduleZone,
+    } }, { configDir: this.configDir });
   }
 
   assertProviderAvailable(config, providerId) {
@@ -512,7 +441,8 @@ export class ProviderModelRefreshRunner {
     if (outcomes.some((outcome) => outcome.status === "success")) {
       return { status: "refreshed", reason: null };
     }
-    return { status: "skipped", reason: "all_providers_unavailable" };
+    return { status: "skipped", reason: outcomes.every((outcome) => outcome.reason === "refresh_already_running")
+      ? "refresh_already_running" : "all_providers_unavailable" };
   }
 
   async refreshProvider(providerId, options = {}) {
@@ -538,7 +468,6 @@ export class ProviderModelRefreshRunner {
 
   async runOnce(options = {}) {
     const targetProvider = normalizeRefreshProviderId(options.provider);
-    const force = options.force !== false;
     const refreshSource =
       typeof options.source === "string" && options.source.trim()
         ? options.source.trim()
@@ -547,56 +476,50 @@ export class ProviderModelRefreshRunner {
         : "explicit";
     const startedMs = this.nowFn();
     const startedAt = operationLogTimestamp(startedMs);
-    if (this.running) {
-      const finishedMs = this.nowFn();
-      this.appendOperationLogFn(
-        {
-          schema_version: 1,
-          operation: "provider_model_refresh",
-          provider: targetProvider || "all",
-          status: "skipped",
-          reason: "refresh_already_running",
-          source: refreshSource,
-          started_at: startedAt,
-          finished_at: operationLogTimestamp(finishedMs),
-          duration_ms: durationMs(startedMs, finishedMs),
-        },
-        { configDir: this.configDir || getConfigDir() }
-      );
-      return { status: "skipped", reason: "refresh_already_running" };
-    }
-    this.running = true;
+    // Reserve the batch synchronously: overlapping calls never queue a second
+    // discovery, and one busy provider does not suppress the others.
+    const targetProviders = this.getTargetProviderIds({ provider: targetProvider });
+    const busyProviders = new Set(targetProviders.filter((id) => this.activeProviders.has(id)));
+    const reservedProviders = targetProviders.filter((id) => !busyProviders.has(id));
+    for (const id of reservedProviders) this.activeProviders.add(id);
     const attemptedAt = startedAt;
     try {
       const config = this.readConfigFn();
-      const targetProviders = this.getTargetProviderIds({
-        provider: targetProvider,
-        force,
-      });
-      if (targetProviders.length === 0) {
-        return {
-          status: "skipped",
-          reason: "refresh_not_due",
-          providers: [],
-        };
-      }
-      const nextRefreshAt = new Date(
-        this.nowFn() + this.refreshIntervalMs
-      ).toISOString();
       const aggregatePatch = {
         provider_models: {},
         provider_runtime: {},
         refresh: {
           last_attempt_at: attemptedAt,
-          next_refresh_at: nextRefreshAt,
-          scheduling_authority: "provider_last_refresh_plus_interval",
         },
       };
+      // A skip owns admission evidence, not a later discovery completion.
+      // Publish all skips before the first await (including providers later in
+      // batch order), preserve their existing discovery metadata, and never
+      // carry those non-owned runtime blocks into the delayed batch write.
+      if (busyProviders.size) {
+        const { params } = this.readParamsFn({ configDir: this.configDir });
+        const skippedRuntime = {};
+        for (const providerId of busyProviders) {
+          skippedRuntime[providerId] = {
+            ...params.provider_runtime?.[providerId],
+            probe_status: 'skipped', refresh_skip_reason: 'refresh_already_running',
+            last_attempt_at: attemptedAt, last_attempt_source: refreshSource,
+            last_error: null,
+          };
+        }
+        this.writeParamsFn({ provider_runtime: skippedRuntime }, { configDir: this.configDir });
+      }
       const specs = this.buildProviderSpecs(config, attemptedAt);
       const outcomes = [];
       for (const providerId of targetProviders) {
         const spec = specs.get(providerId);
         const providerStartedMs = this.nowFn();
+        if (busyProviders.has(providerId)) {
+          outcomes.push({ provider: providerId, status: 'skipped', reason: 'refresh_already_running',
+            model_count: 0, started_ms: providerStartedMs });
+          continue;
+        }
+
         try {
           this.assertProviderAvailable(config, providerId);
         } catch (err) {
@@ -619,6 +542,7 @@ export class ProviderModelRefreshRunner {
           outcomes.push({
             provider: spec.provider,
             status: "success",
+            process_cleanup: discovery.process_cleanup,
             model_count: Array.isArray(discovery.models)
               ? discovery.models.length
               : 0,
@@ -635,12 +559,18 @@ export class ProviderModelRefreshRunner {
           outcomes.push({
             provider: spec.provider,
             status: "error",
+            process_cleanup: err.details?.process_cleanup,
             model_count: 0,
             error: err,
             started_ms: providerStartedMs,
           });
         }
       }
+      for (const outcome of outcomes) {
+        if (busyProviders.has(outcome.provider)) continue;
+        aggregatePatch.provider_runtime[outcome.provider].last_attempt_source = refreshSource;
+        aggregatePatch.provider_runtime[outcome.provider].process_cleanup = outcome.process_cleanup || null;
+      }
       const overall = this.buildOverallStatus(outcomes);
       if (overall.status === "refreshed") {
         aggregatePatch.refresh.last_success_at = attemptedAt;
@@ -663,15 +593,16 @@ export class ProviderModelRefreshRunner {
             duration_ms: durationMs(outcome.started_ms, finishedMs),
             model_count: outcome.model_count,
             config_options_count: outcome.config_options_count ?? null,
+            process_cleanup: outcome.process_cleanup,
             last_success_at:
               outcome.status === "success" ? attemptedAt : undefined,
-            next_refresh_at: nextRefreshAt,
-            scheduling_authority: "provider_last_refresh_plus_interval",
+            next_refresh_at: this.nextRefreshAt,
+            scheduling_authority: PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY,
             params_path: writeResult.path,
             error:
               outcome.status === "success"
                 ? null
-                : sanitizeOperationLogError(outcome.error),
+                : outcome.error ? sanitizeOperationLogError(outcome.error) : null,
           },
           { configDir: this.configDir || getConfigDir() }
         );
@@ -699,14 +630,15 @@ export class ProviderModelRefreshRunner {
           status: outcome.status,
           reason: outcome.reason || null,
           model_count: outcome.model_count,
+          process_cleanup: outcome.process_cleanup || null,
           error:
             outcome.status === "success"
               ? null
-              : truncateError(outcome.error),
+              : outcome.error ? truncateError(outcome.error) : null,
         })),
       };
     } finally {
-      this.running = false;
+      for (const id of reservedProviders) this.activeProviders.delete(id);
     }
   }
 
@@ -721,28 +653,51 @@ export class ProviderModelRefreshRunner {
       background_refresh_started: this.started === true,
       background_refresh_timer_active: Boolean(this.timer),
       explicit_refresh_available: true,
-      refresh_running: this.running === true,
-      startup_delay_ms: this.startupDelayMs,
-      refresh_interval_ms: this.refreshIntervalMs,
-      scheduling_authority: "provider_last_refresh_plus_interval",
+      refresh_running: this.activeProviders.size > 0,
+      next_refresh_at: this.nextRefreshAt,
+      time_zone: this.scheduleZone,
+      scheduling_authority: PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY,
       providers: this.getAllProviderRefreshStatus(),
     };
   }
 
-  scheduleNext(options = {}) {
-    if (!this.started || this.timer) return;
-    const delayMs = this.computeNextDelay(options);
-    this.timer = this.setTimeoutFn(async () => {
-      this.timer = null;
-      try {
-        await this.runOnce({ source: "background", force: false });
-      } finally {
+  // A bounded clock check only recalculates after a zone change. It never
+  // retries discovery and does not append an operation result.
+  watchClock() {
+    if (!this.started) return;
+    this.clockTimer = this.setTimeoutFn(() => {
+      this.clockTimer = null;
+      const zone = providerModelRefreshZone();
+      if (zone !== this.scheduleZone) {
+        if (this.timer) this.clearTimeoutFn(this.timer);
+        this.timer = null;
         this.scheduleNext();
       }
-    }, delayMs);
-    if (typeof this.timer?.unref === "function") {
-      this.timer.unref();
-    }
+      this.watchClock();
+    }, 60_000);
+    this.clockTimer?.unref?.();
   }
 
+  scheduleNext() {
+    if (!this.started || this.timer) return;
+    const now = this.nowFn();
+    const next = nextProviderModelRefreshTime(now);
+    this.scheduleZone = providerModelRefreshZone();
+    this.nextRefreshAt = new Date(next).toISOString();
+    this.persistSchedule();
+    const timer = this.setTimeoutFn(async () => {
+      if (!this.started || this.timer !== timer) return;
+      this.timer = null;
+      // Advance the calendar before discovery so results and Preferences share
+      // the next real timer even while a provider is unavailable or slow.
+      this.scheduleNext();
+      // Timers are notifications, not catch-up authority. Permit only normal
+      // sub-second dispatch jitter at the scheduled instant; a suspended or
+      // delayed Host skips the expired slot and keeps tomorrow's timer.
+      if (this.nowFn() - next > 1000 || this.nowFn() < next) return;
+      await this.runOnce({ source: "background", force: true });
+    }, next - now);
+    this.timer = timer;
+    this.timer?.unref?.();
+  }
 }

package/host-service/provider-model-refresh-schedule.mjs

@@ -0,0 +1,11 @@
+// Calendar arithmetic intentionally uses the Host's local zone (including DST).
+export const PROVIDER_MODEL_REFRESH_SCHEDULING_AUTHORITY = "host_local_daily_0900";
+export function nextProviderModelRefreshTime(nowMs) {
+  const next = new Date(nowMs);
+  next.setHours(9, 0, 0, 0);
+  if (next.getTime() <= nowMs) next.setDate(next.getDate() + 1);
+  return next.getTime();
+}
+export function providerModelRefreshZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}

package/host-service/provider-resume-contract.mjs

@@ -39,6 +39,7 @@ export function assertHostSessionFixtureStart({
   sessionId,
   resumeSessionId,
   fixtureResumeGeneration,
+  fork = false,
 }) {
   const normalizedSessionId = normalizeResumeIdentity(sessionId);
   if (!normalizedSessionId) {
@@ -49,20 +50,25 @@ export function assertHostSessionFixtureStart({
     fixtureResumeGeneration,
     normalizedResumeSessionId ? 1 : 0
   );
+  const branchStart = fork === true;
+  if (branchStart && !normalizedResumeSessionId) {
+    throw new Error("host-session fixture branch requires a source sessionId");
+  }
   if (
     normalizedResumeSessionId &&
-    normalizedResumeSessionId !== normalizedSessionId
+    normalizedResumeSessionId !== normalizedSessionId &&
+    !branchStart
   ) {
     throw new Error(
       "host-session fixture resume identity must equal sessionId"
     );
   }
-  if (normalizedResumeSessionId && generation < 1) {
+  if (normalizedResumeSessionId && !branchStart && generation < 1) {
     throw new Error(
       "resumed host-session fixture requires a positive generation"
     );
   }
-  if (!normalizedResumeSessionId && generation !== 0) {
+  if ((!normalizedResumeSessionId || branchStart) && generation !== 0) {
     throw new Error("fresh host-session fixture requires generation zero");
   }
   return generation;