hiwork-core 0.0.35 → 0.0.37

package/lib/browser-login.js

@@ -146,12 +146,23 @@ export async function startBrowserLogin(opts) {
     }
     return { authorizeUrl, state };
 }
-/** 把失败写进状态并结束等待态（清 browserLogin 与请求字段）。 */
-async function failBrowserLogin(state, loginError) {
-    await state.patch({
-        set: { lastError: loginError },
-        unset: ['browserLoginRequest', 'browserLogin'],
-    }).catch(() => { });
+/**
+ * 把失败写进状态并结束等待态（清 browserLogin 与请求字段）。
+ *
+ * ⚠️ 写回可能失败（settings 尚未可写 / entry 被 HMR 摘掉）：那样等待态不会结束，界面会停在
+ * 「等待完成授权」而没有任何线索。这里不静默吞掉——`state.patch` 已带退避重试，还能抛出来
+ * 说明重试窗口也用尽了。
+ */
+async function failBrowserLogin(state, loginError, log) {
+    try {
+        await state.patch({
+            set: { lastError: loginError },
+            unset: ['browserLoginRequest', 'browserLogin'],
+        });
+    }
+    catch (error) {
+        log(`hiwork-core: 浏览器授权失败态写回被拒，界面可能停在「等待完成授权」（${error instanceof Error ? error.message : typeof error}）`);
+    }
     return loginError;
 }
 /**
@@ -161,17 +172,32 @@ async function failBrowserLogin(state, loginError) {
  * `browserLogin` 是持久化的。宿主一旦重启（应用重开、DSH 崩溃重启、开发期 HMR），
  * 两者就永久错位：所有回调都被 `completeBrowserLogin` 的「没有待完成的授权请求」丢弃，
  * 界面却仍按持久化的 `browserLogin` 停在「等待完成授权」，用户只能靠「取消」脱困。
+ * 更糟的是登录门挂载时会拿这个**已经死掉的**授权 URL 自动打开浏览器，用户无论怎么
+ * 在浏览器里完成授权都回不来——这正是「浏览器打开了但授权回不到桌面端」的成因。
  *
  * 因此启动即把这种**不可能完成**的等待态收尾成失败：写一条 lastError 并清掉等待字段，
  * 让用户回到登录入口重新发起。没有等待态时不动任何状态。
+ *
+ * ⚠️ **返回值必须被检查，调用方必须重试**：`apply()` 跑在任何 settings 写入可用之前，
+ * 此时写回会被 `settings namespace "<ns>" is not registered` 拒绝（实测 1.0.8 桌面端：
+ * apply 时刻命名空间尚未注册，约 3.7s 后才可写）。捕获后吞掉这个拒绝，等于等待态永远
+ * 清不掉——本函数原先正是 `.catch(() => {})` + 单次调用，缺陷即由此而来。
+ *
+ * @returns `true` = 已收尾（原本就没有等待态，或已成功清掉）；`false` = 写回被拒，需重试。
  */
 export async function reconcileStaleBrowserLogin(state, value) {
     if (value.browserLogin === undefined)
-        return;
-    await state.patch({
-        set: { lastError: { code: 'AUTH_FAILED', message: '上次浏览器授权未完成，请重新登录' } },
-        unset: ['browserLoginRequest', 'browserLogin'],
-    }).catch(() => { });
+        return true;
+    try {
+        await state.patch({
+            set: { lastError: { code: 'AUTH_FAILED', message: '上次浏览器授权未完成，请重新登录' } },
+            unset: ['browserLoginRequest', 'browserLogin'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * 处理 `hiwork://auth/callback`：校验 state → 兑换一次性 code → 写会话凭据 → 复用供给尾部。
@@ -201,20 +227,20 @@ export async function completeBrowserLogin(input, opts) {
     try {
         if (now() - pending.startedAt > BROWSER_LOGIN_TTL_MS) {
             log('hiwork-core: 浏览器授权回调已超时（超过 10 分钟），已拒绝');
-            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权已超时，请重新登录' });
+            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权已超时，请重新登录' }, log);
         }
         if (typeof input.error === 'string' && input.error !== '') {
             // 授权页拒绝 / 网关下发 error：不兑换 code。error 截断后入日志，防日志注入。
             log(`hiwork-core: 浏览器授权被拒绝（${input.error.slice(0, 64)}）`);
-            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权被取消或失败，请重新登录' });
+            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权被取消或失败，请重新登录' }, log);
         }
         if (typeof input.code !== 'string' || input.code === '') {
             log('hiwork-core: 浏览器授权回调缺少 code，已丢弃');
-            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权回调不完整，请重新登录' });
+            return await failBrowserLogin(opts.state, { code: 'AUTH_FAILED', message: '授权回调不完整，请重新登录' }, log);
         }
         const baseURL = opts.value.baseURL;
         if (baseURL === undefined || baseURL === '')
-            return await failBrowserLogin(opts.state, NO_BASE_URL_ERROR);
+            return await failBrowserLogin(opts.state, NO_BASE_URL_ERROR, log);
         const { sessionCookie, user } = await opts.gateway.exchangeCode({
             code: input.code,
             codeVerifier: pending.codeVerifier,
@@ -240,7 +266,7 @@ export async function completeBrowserLogin(input, opts) {
     }
     catch (error) {
         const loginError = toLoginError(error, '无法连接网关，请检查 baseURL 或网络');
-        return await failBrowserLogin(opts.state, loginError);
+        return await failBrowserLogin(opts.state, loginError, log);
     }
     finally {
         pendingAuth = undefined;

package/lib/client.js

@@ -1876,6 +1876,8 @@ function AboutSection({ appVersion }) {
 // src/client/daily-data.ts
 var DAILY_CHANNEL = "/hiwork-daily";
 var DAILY_FAILURE_TTL_MS = 5 * 6e4;
+var DAILY_LOCAL_RETRY_MS = 2e3;
+var DAILY_LOCAL_FAILURE_CODES = ["SESSION_EXPIRED", "GATEWAY_UNREACHABLE"];
 var DailyRpcError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -1947,27 +1949,38 @@ var DailyDataStore = class {
     this.now = options.now ?? (() => Date.now());
     this.localDay = options.localDay ?? (() => localDayIndex());
     this.failureTtlMs = options.failureTtlMs ?? DAILY_FAILURE_TTL_MS;
+    this.localRetryMs = options.localRetryMs ?? DAILY_LOCAL_RETRY_MS;
   }
   entry;
   failureAt;
+  /** 上一次失败是否为宿主本地前置失败（{@link DAILY_LOCAL_FAILURE_CODES}）——决定节流用哪个 TTL。 */
+  localFailure = false;
   pending;
   now;
   localDay;
   failureTtlMs;
+  localRetryMs;
   /** 清空缓存与防抖状态（登出 / 换账号时调用）。 */
   clear() {
     this.entry = void 0;
     this.failureAt = void 0;
+    this.localFailure = false;
     this.pending = void 0;
   }
   /**
-   * 当日条目：同一本地日内命中缓存直接返回（不发 RPC）；失败防抖期内返回 null 不
-   * 重复打网关；并发调用合并为同一次 RPC。返回 null 即「暂无可展示内容」。
+   * 当日条目：同一本地日内命中缓存直接返回（不发 RPC）；节流期内返回 null 不重复打网关；
+   * 并发调用合并为同一次 RPC。返回 null 即「暂无可展示内容」。
+   *
+   * 节流时长分两档：宿主本地前置失败（未登录 / 网关未配置）只等 {@link DAILY_LOCAL_RETRY_MS}，
+   * 其余失败等 {@link DAILY_FAILURE_TTL_MS}——理由见两个常量的说明（首次安装必先启动后登录）。
    */
   async getToday() {
     const day = this.localDay();
     if (this.entry !== void 0 && this.entry.day === day) return this.entry.view;
-    if (this.failureAt !== void 0 && this.now() - this.failureAt < this.failureTtlMs) return null;
+    if (this.failureAt !== void 0) {
+      const ttl = this.localFailure ? this.localRetryMs : this.failureTtlMs;
+      if (this.now() - this.failureAt < ttl) return null;
+    }
     if (this.pending === void 0) {
       this.pending = this.fetchToday(day).finally(() => {
         this.pending = void 0;
@@ -1989,17 +2002,25 @@ var DailyDataStore = class {
       return null;
     }
   }
-  /** 单次 today 拉取：成功（含池空）写缓存；任何失败进入 5 分钟防抖并返回 null。 */
+  /**
+   * 单次 today 拉取：成功（含池空）写缓存；任何失败进入节流并返回 null。
+   *
+   * 失败分两档记：{@link DAILY_LOCAL_FAILURE_CODES} 是宿主在打网之前判定的（无网关流量、登录后必然变化），
+   * 只记短节流；其余（网关透传失败、形状非法、未知错误）记满 {@link DAILY_FAILURE_TTL_MS}。
+   */
   async fetchToday(day) {
     try {
       const raw = await this.rpc.call(DAILY_CHANNEL, "today", {});
       const response = parseTodayResponse(unwrapDailyResult(raw));
       if (response === void 0) throw new DailyRpcError("internal", "\u6BCF\u65E5\u4E00\u53E5\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002");
       this.failureAt = void 0;
+      this.localFailure = false;
       const view = response.item === null ? null : { ...response.item, date: response.date };
       this.entry = { view, day };
       return view;
-    } catch {
+    } catch (error) {
+      const code = error instanceof DailyRpcError ? error.code : "";
+      this.localFailure = DAILY_LOCAL_FAILURE_CODES.includes(code);
       this.failureAt = this.now();
       return null;
     }
@@ -7195,6 +7216,7 @@ function apply(ctx) {
   ctx.effect(() => observeAccountChange(controller.inject().hooks.aiRouterCard, () => {
     usage.clear();
     sessionCost.clear();
+    dailyQuotes.clear();
     managedMcp.clear();
     managedSkills.clear();
     managedWorkbench.clear();

package/lib/index.js

@@ -8267,7 +8267,7 @@ defineMethod("transform", [
 ], ({ inner }, isInner) => inner.toString(isInner));
 
 // src/version.ts
-var PKG_VERSION = false ? "dev" : "0.0.35";
+var PKG_VERSION = false ? "dev" : "0.0.37";
 
 // src/browser-login.ts
 import { createHash, randomBytes, randomUUID } from "node:crypto";
@@ -8549,21 +8549,28 @@ async function startBrowserLogin(opts) {
   }
   return { authorizeUrl, state };
 }
-async function failBrowserLogin(state, loginError) {
-  await state.patch({
-    set: { lastError: loginError },
-    unset: ["browserLoginRequest", "browserLogin"]
-  }).catch(() => {
-  });
+async function failBrowserLogin(state, loginError, log) {
+  try {
+    await state.patch({
+      set: { lastError: loginError },
+      unset: ["browserLoginRequest", "browserLogin"]
+    });
+  } catch (error) {
+    log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u5931\u8D25\u6001\u5199\u56DE\u88AB\u62D2\uFF0C\u754C\u9762\u53EF\u80FD\u505C\u5728\u300C\u7B49\u5F85\u5B8C\u6210\u6388\u6743\u300D\uFF08${error instanceof Error ? error.message : typeof error}\uFF09`);
+  }
   return loginError;
 }
 async function reconcileStaleBrowserLogin(state, value) {
-  if (value.browserLogin === void 0) return;
-  await state.patch({
-    set: { lastError: { code: "AUTH_FAILED", message: "\u4E0A\u6B21\u6D4F\u89C8\u5668\u6388\u6743\u672A\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" } },
-    unset: ["browserLoginRequest", "browserLogin"]
-  }).catch(() => {
-  });
+  if (value.browserLogin === void 0) return true;
+  try {
+    await state.patch({
+      set: { lastError: { code: "AUTH_FAILED", message: "\u4E0A\u6B21\u6D4F\u89C8\u5668\u6388\u6743\u672A\u5B8C\u6210\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" } },
+      unset: ["browserLoginRequest", "browserLogin"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
 }
 async function completeBrowserLogin(input, opts) {
   const now = opts.now ?? Date.now;
@@ -8581,18 +8588,18 @@ async function completeBrowserLogin(input, opts) {
   try {
     if (now() - pending.startedAt > BROWSER_LOGIN_TTL_MS) {
       log("hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u5DF2\u8D85\u65F6\uFF08\u8D85\u8FC7 10 \u5206\u949F\uFF09\uFF0C\u5DF2\u62D2\u7EDD");
-      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u5DF2\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" });
+      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u5DF2\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" }, log);
     }
     if (typeof input.error === "string" && input.error !== "") {
       log(`hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u88AB\u62D2\u7EDD\uFF08${input.error.slice(0, 64)}\uFF09`);
-      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u88AB\u53D6\u6D88\u6216\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" });
+      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u88AB\u53D6\u6D88\u6216\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" }, log);
     }
     if (typeof input.code !== "string" || input.code === "") {
       log("hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u56DE\u8C03\u7F3A\u5C11 code\uFF0C\u5DF2\u4E22\u5F03");
-      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u56DE\u8C03\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" });
+      return await failBrowserLogin(opts.state, { code: "AUTH_FAILED", message: "\u6388\u6743\u56DE\u8C03\u4E0D\u5B8C\u6574\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55" }, log);
     }
     const baseURL = opts.value.baseURL;
-    if (baseURL === void 0 || baseURL === "") return await failBrowserLogin(opts.state, NO_BASE_URL_ERROR);
+    if (baseURL === void 0 || baseURL === "") return await failBrowserLogin(opts.state, NO_BASE_URL_ERROR, log);
     const { sessionCookie, user } = await opts.gateway.exchangeCode({
       code: input.code,
       codeVerifier: pending.codeVerifier,
@@ -8617,7 +8624,7 @@ async function completeBrowserLogin(input, opts) {
     return null;
   } catch (error) {
     const loginError = toLoginError(error, "\u65E0\u6CD5\u8FDE\u63A5\u7F51\u5173\uFF0C\u8BF7\u68C0\u67E5 baseURL \u6216\u7F51\u7EDC");
-    return await failBrowserLogin(opts.state, loginError);
+    return await failBrowserLogin(opts.state, loginError, log);
   } finally {
     pendingAuth = void 0;
   }
@@ -19959,19 +19966,45 @@ function pathOps(patch) {
   for (const key of patch.unset ?? []) ops.push({ op: "unset", path: [key] });
   return ops;
 }
-async function writeNamespace(settings, ns, ops) {
-  for (let attempt = 0; attempt < 2; attempt++) {
+var HMR_NESTED_FRAGMENT = "HMR transactions cannot be nested";
+var ENTRY_UNAVAILABLE_FRAGMENTS = ["No configurable plugin entry", "is no longer configurable"];
+var WRITE_DEADLINE_MS = 15e3;
+var WRITE_BACKOFF_MIN_MS = 50;
+var WRITE_BACKOFF_MAX_MS = 1e3;
+function isHmrNestedWriteError(error) {
+  return error instanceof Error && error.message.includes(HMR_NESTED_FRAGMENT);
+}
+function isRetriableWriteError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.name === "SettingsConflictError" || isHmrNestedWriteError(error) || ENTRY_UNAVAILABLE_FRAGMENTS.some((fragment) => error.message.includes(fragment));
+}
+function delay(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
+  });
+}
+async function writeNamespace(settings, ns, ops, opts = {}) {
+  const deadline = Date.now() + (opts.deadlineMs ?? WRITE_DEADLINE_MS);
+  const maxBackoff = opts.maxBackoffMs ?? WRITE_BACKOFF_MAX_MS;
+  let backoff = opts.minBackoffMs ?? WRITE_BACKOFF_MIN_MS;
+  for (; ; ) {
     const descriptor = settings.describe().find((d) => d.ns === ns);
-    if (descriptor === void 0) throw new Error(`settings namespace "${ns}" is not registered`);
+    if (descriptor === void 0) {
+      if (Date.now() >= deadline) throw new Error(`settings namespace "${ns}" is not registered`);
+      await delay(backoff);
+      backoff = Math.min(backoff * 2, maxBackoff);
+      continue;
+    }
     try {
       await settings.mutate(ns, ops, descriptor.revision);
       return;
     } catch (error) {
-      if (error instanceof Error && error.name === "SettingsConflictError") continue;
-      throw error;
+      if (!isRetriableWriteError(error)) throw error;
+      if (Date.now() >= deadline) throw error;
+      await delay(backoff);
+      backoff = Math.min(backoff * 2, maxBackoff);
     }
   }
-  throw new Error(`settings namespace "${ns}" write conflicted repeatedly`);
 }
 function readDefaultSelection(settings) {
   const value = settings.describe().find((d) => d.ns === DEFAULT_MODEL_NS)?.value;
@@ -20188,6 +20221,8 @@ async function importLegacyMenuSection(opts) {
     log(`hiwork-core: \u65E7\u7248\u83DC\u5355\u504F\u597D\u8FC1\u79FB\u5931\u8D25\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
   }
 }
+var STALE_BROWSER_LOGIN_RECONCILE_DELAYS_MS = [0, 500, 1500, 4e3, 8e3];
+var LOGIN_REQUEST_POLL_MS = 200;
 function apply(ctx, config) {
   const current = () => plainValue(config);
   const settings = ctx.get("settings");
@@ -20266,9 +20301,7 @@ function apply(ctx, config) {
     }).catch(() => {
     });
   };
-  ctx.on("settings/document-updated", (ns) => {
-    if (ns !== NS) return;
-    requestClientPolicy();
+  const dispatchSectionChange = () => {
     const value = current();
     const requested = value.pendingLogin ?? value.browserLoginRequest ?? value.refreshRequest ?? value.logoutRequest;
     if (requested === void 0) return;
@@ -20286,18 +20319,36 @@ function apply(ctx, config) {
         });
       } catch (error) {
         ctx.logger.error("hiwork-core: ai-router section change failed", error);
+        if (isHmrNestedWriteError(error)) {
+          ctx.logger.warn("hiwork-core: \u8F6E\u8BE2\u4E0A\u4E0B\u6587\u5DF2\u88AB HMR \u4E8B\u52A1\u6C61\u67D3\uFF0C\u672C\u5B9E\u4F8B\u540E\u7EED\u56DE\u5199\u5C06\u5168\u90E8\u88AB\u62D2\uFF08\u9700\u91CD\u6302\u63D2\u4EF6\u6216\u91CD\u542F\u5E94\u7528\uFF09");
+        }
         await ports.credentials.unset(PENDING_PASSWORD_REF).catch(() => {
         });
-        await ports.state.patch({
-          set: { lastError: { code: "GATEWAY_UNREACHABLE", message: "\u7F51\u5173\u63D2\u4EF6\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E\u4E0E\u7F51\u7EDC" } },
-          unset: ["pendingLogin", "browserLoginRequest", "browserLogin", "refreshRequest", "logoutRequest"]
-        }).catch(() => {
-        });
+        try {
+          await ports.state.patch({
+            set: { lastError: { code: "GATEWAY_UNREACHABLE", message: "\u7F51\u5173\u63D2\u4EF6\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u914D\u7F6E\u4E0E\u7F51\u7EDC" } },
+            unset: ["pendingLogin", "browserLoginRequest", "browserLogin", "refreshRequest", "logoutRequest"]
+          });
+        } catch (patchError) {
+          ctx.logger.error("hiwork-core: ai-router \u8BF7\u6C42\u5B57\u6BB5\u6E05\u7406\u5931\u8D25\uFF0C\u754C\u9762\u53EF\u80FD\u505C\u5728\u7B49\u5F85\u4E2D", patchError);
+        }
       }
     })().finally(() => {
       inFlight = void 0;
     });
-  });
+  };
+  ctx.effect(() => {
+    const consume = () => {
+      requestClientPolicy();
+      dispatchSectionChange();
+    };
+    consume();
+    const timer = setInterval(consume, LOGIN_REQUEST_POLL_MS);
+    timer.unref?.();
+    return () => {
+      clearInterval(timer);
+    };
+  }, "hiwork-core: login request poll");
   void ctx.root.loader.await().then(() => importLegacyMenuSection({
     ctx,
     settings,
@@ -20306,7 +20357,15 @@ function apply(ctx, config) {
     ctx.logger.warn(`hiwork-core: \u65E7\u7248\u83DC\u5355\u504F\u597D\u8FC1\u79FB\u672A\u6267\u884C\uFF08${error instanceof Error ? error.name : typeof error}\uFF09`);
   });
   requestClientPolicy();
-  void reconcileStaleBrowserLogin(ports.state, current());
+  void (async () => {
+    for (const delay2 of STALE_BROWSER_LOGIN_RECONCILE_DELAYS_MS) {
+      if (delay2 > 0) await new Promise((resolve3) => {
+        setTimeout(resolve3, delay2);
+      });
+      if (await reconcileStaleBrowserLogin(ports.state, current())) return;
+    }
+    ctx.logger.warn("hiwork-core: \u6D4F\u89C8\u5668\u6388\u6743\u7B49\u5F85\u6001\u5BF9\u8D26\u672A\u5199\u5165\uFF0C\u754C\u9762\u53EF\u80FD\u505C\u5728\u300C\u7B49\u5F85\u5B8C\u6210\u6388\u6743\u300D");
+  })();
   const connection = ctx.get("connection");
   if (connection === void 0) throw new Error("connection service unavailable");
   ctx.effect(() => registerUsageRpc({ connection, logger: ctx.logger }, {
@@ -20638,8 +20697,10 @@ export {
   apply,
   createDefaultModelPort,
   inject,
+  isHmrNestedWriteError,
   name,
   plainValue,
   projectLoginMode,
-  registerIpcMessageHandler
+  registerIpcMessageHandler,
+  writeNamespace
 };

package/lib/types/browser-login.d.ts

@@ -80,11 +80,20 @@ export declare function startBrowserLogin(opts: BrowserLoginStartPorts): Promise
  * `browserLogin` 是持久化的。宿主一旦重启（应用重开、DSH 崩溃重启、开发期 HMR），
  * 两者就永久错位：所有回调都被 `completeBrowserLogin` 的「没有待完成的授权请求」丢弃，
  * 界面却仍按持久化的 `browserLogin` 停在「等待完成授权」，用户只能靠「取消」脱困。
+ * 更糟的是登录门挂载时会拿这个**已经死掉的**授权 URL 自动打开浏览器，用户无论怎么
+ * 在浏览器里完成授权都回不来——这正是「浏览器打开了但授权回不到桌面端」的成因。
  *
  * 因此启动即把这种**不可能完成**的等待态收尾成失败：写一条 lastError 并清掉等待字段，
  * 让用户回到登录入口重新发起。没有等待态时不动任何状态。
+ *
+ * ⚠️ **返回值必须被检查，调用方必须重试**：`apply()` 跑在任何 settings 写入可用之前，
+ * 此时写回会被 `settings namespace "<ns>" is not registered` 拒绝（实测 1.0.8 桌面端：
+ * apply 时刻命名空间尚未注册，约 3.7s 后才可写）。捕获后吞掉这个拒绝，等于等待态永远
+ * 清不掉——本函数原先正是 `.catch(() => {})` + 单次调用，缺陷即由此而来。
+ *
+ * @returns `true` = 已收尾（原本就没有等待态，或已成功清掉）；`false` = 写回被拒，需重试。
  */
-export declare function reconcileStaleBrowserLogin(state: AiRouterStatePort, value: Pick<AiRouterNamespaceValue, 'browserLogin'>): Promise<void>;
+export declare function reconcileStaleBrowserLogin(state: AiRouterStatePort, value: Pick<AiRouterNamespaceValue, 'browserLogin'>): Promise<boolean>;
 /**
  * 处理 `hiwork://auth/callback`：校验 state → 兑换一次性 code → 写会话凭据 → 复用供给尾部。
  *

package/lib/types/client/daily-data.d.ts

@@ -20,6 +20,22 @@ export declare const DAILY_ENDPOINTS: readonly ["today", "random"];
 export type DailyEndpoint = (typeof DAILY_ENDPOINTS)[number];
 /** 失败防抖 TTL：5 分钟——观察循环逐帧触发，绝不逐帧重试网关。 */
 export declare const DAILY_FAILURE_TTL_MS: number;
+/**
+ * 失败防抖 TTL 对「宿主本地前置失败」的替代值（毫秒）。
+ *
+ * {@link DAILY_LOCAL_FAILURE_CODES} 里的错误由 Host 在**打网之前**判定（未登录 / 网关地址未配置），
+ * 不产生任何网关流量；而它们在「用户完成登录」或「配置补上」之后必然变化。若也计入 5 分钟防抖，
+ * 就会把「登录后立刻能用」变成「最多再等 5 分钟」——**首次安装正是这个顺序**（先启动、后登录），
+ * 用户看到的是「首次启动没有每日一句，切几次页面 / 关掉重开才有」。
+ * 2 秒只为压住观察循环逐帧触发时的空转（并发已由 `pending` 合并为至多一次在途），不改变可见行为。
+ */
+export declare const DAILY_LOCAL_RETRY_MS = 2000;
+/**
+ * Host 在打网之前判定的失败 code（见 `src/daily-rpc.ts` 的 `handleDailyEndpoint`）：
+ * `SESSION_EXPIRED`（未登录 / 会话失效）与 `GATEWAY_UNREACHABLE`（网关地址未配置）。
+ * 只豁免这两个明确「本地」的 code；网关透传的失败与未知错误一律按真实上游失败进 5 分钟防抖。
+ */
+export declare const DAILY_LOCAL_FAILURE_CODES: readonly ["SESSION_EXPIRED", "GATEWAY_UNREACHABLE"];
 /**
  * 单条每日一句的视图形状（网关 JSON 按结构重声明后的归一结果）：
  * 可选字段缺省一律归一为空串 / 空数组，视图据此隐藏对应区块。
@@ -90,20 +106,27 @@ export declare class DailyDataStore implements DailyQuoteLoader {
     private readonly rpc;
     private entry;
     private failureAt;
+    /** 上一次失败是否为宿主本地前置失败（{@link DAILY_LOCAL_FAILURE_CODES}）——决定节流用哪个 TTL。 */
+    private localFailure;
     private pending;
     private readonly now;
     private readonly localDay;
     private readonly failureTtlMs;
+    private readonly localRetryMs;
     constructor(rpc: DailyRpcPort, options?: {
         now?: (() => number) | undefined;
         localDay?: (() => number) | undefined;
         failureTtlMs?: number | undefined;
+        localRetryMs?: number | undefined;
     });
     /** 清空缓存与防抖状态（登出 / 换账号时调用）。 */
     clear(): void;
     /**
-     * 当日条目：同一本地日内命中缓存直接返回（不发 RPC）；失败防抖期内返回 null 不
-     * 重复打网关；并发调用合并为同一次 RPC。返回 null 即「暂无可展示内容」。
+     * 当日条目：同一本地日内命中缓存直接返回（不发 RPC）；节流期内返回 null 不重复打网关；
+     * 并发调用合并为同一次 RPC。返回 null 即「暂无可展示内容」。
+     *
+     * 节流时长分两档：宿主本地前置失败（未登录 / 网关未配置）只等 {@link DAILY_LOCAL_RETRY_MS}，
+     * 其余失败等 {@link DAILY_FAILURE_TTL_MS}——理由见两个常量的说明（首次安装必先启动后登录）。
      */
     getToday(): Promise<DailyTodayView | null>;
     /**
@@ -111,6 +134,11 @@ export declare class DailyDataStore implements DailyQuoteLoader {
      * 失败 / 暂无随机条目返回 null（视图保持当前条目、无任何提示）。
      */
     getRandom(excludeId?: number): Promise<DailyQuoteView | null>;
-    /** 单次 today 拉取：成功（含池空）写缓存；任何失败进入 5 分钟防抖并返回 null。 */
+    /**
+     * 单次 today 拉取：成功（含池空）写缓存；任何失败进入节流并返回 null。
+     *
+     * 失败分两档记：{@link DAILY_LOCAL_FAILURE_CODES} 是宿主在打网之前判定的（无网关流量、登录后必然变化），
+     * 只记短节流；其余（网关透传失败、形状非法、未知错误）记满 {@link DAILY_FAILURE_TTL_MS}。
+     */
     private fetchToday;
 }

package/lib/types/index.d.ts

@@ -133,6 +133,25 @@ export type SettingsPathOp = {
     op: 'unset';
     path: readonly string[];
 };
+/** 失败是否是「事务内写」——调用方据此判断轮询上下文已被 HMR 事务污染（见 apply）。 */
+export declare function isHmrNestedWriteError(error: unknown): boolean;
+/**
+ * 写一个命名空间（= profile entry id）。
+ *
+ * 每次尝试都重读 `describe()` 取最新 revision；可重试错误在截止时间前带退避重试，超时后
+ * 抛出**真实**错误——不降级成「conflicted repeatedly」，免得把根因从日志里抹掉。
+ * 退避上限 1s：命名空间注册与 HMR 事务都在秒级内收敛，重试代价可忽略。
+ *
+ * @param settings - settings 服务。
+ * @param ns - 命名空间（profile entry id）。
+ * @param ops - 路径操作。
+ * @param opts - 重试窗口与退避（单测用来把窗口压到毫秒级）。
+ */
+export declare function writeNamespace(settings: SettingsForms, ns: string, ops: SettingsPathOp[], opts?: {
+    deadlineMs?: number;
+    minBackoffMs?: number;
+    maxBackoffMs?: number;
+}): Promise<void>;
 /** 校正默认模型要用到的 llm 注册表部分（便于单测注入假实现）。 */
 export interface LlmRouteRegistry {
     listProviders(): readonly {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hiwork-core",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "type": "module",
   "description": "HiWork 企业统一登录与模型自动供给插件（ai-router 网关登录，Web 表单，无 CLI 认证）",
   "license": "UNLICENSED",