nolo-cli 0.157.0-alpha.1 → 0.157.0

package/settingThunks-N6XFWPOU.js

@@ -0,0 +1,923 @@
+import {
+  DEFAULT_USER_PREFERENCE_PROFILE,
+  SYSTEM_DEFAULT_AGENT_ID,
+  hasOwn,
+  normalizeAgentUpdateFieldList,
+  normalizeAuthorityHomeServerSetting,
+  normalizeDefaultAgentIdSetting,
+  normalizePolicyLevelSetting,
+  normalizeSystemBuiltinSkills,
+  normalizeTonePresetSetting,
+  omitKeys,
+  resolveDefaultAgentIdSetting
+} from "./chunk-VYNMQ6HW.js";
+import {
+  require_react
+} from "./chunk-YDH3FDFQ.js";
+import {
+  patch,
+  readAndWait,
+  toTimestampMs,
+  upsert,
+  write
+} from "./chunk-CDLP56BS.js";
+import "./chunk-3PVYUPXK.js";
+import "./chunk-NHEWV5FD.js";
+import "./chunk-MAYW6V3E.js";
+import {
+  getRuntimeServerContext
+} from "./chunk-43OFVLWJ.js";
+import "./chunk-UEILX4EV.js";
+import {
+  createAction,
+  createAsyncThunk
+} from "./chunk-WRCZXJ4N.js";
+import {
+  fetchFromServer
+} from "./chunk-6Q7UTJKR.js";
+import "./chunk-QQ56R7KS.js";
+import "./chunk-OW765XBU.js";
+import {
+  getSessionGenerationForState,
+  selectIdentityUserId
+} from "./chunk-PXYBUFDB.js";
+import "./chunk-D2MDMY2M.js";
+import {
+  DEFAULT_SYSTEM_AGENT_CAPABILITIES
+} from "./chunk-EUGTFFO6.js";
+import "./chunk-Y6ORVLSS.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import "./chunk-7DPNBQSV.js";
+import "./chunk-LOEO7LRC.js";
+import "./chunk-M2EJHDJP.js";
+import {
+  createUserKey,
+  createUserPreferenceKey,
+  ulid
+} from "./chunk-5EMSBTQ6.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-QSJ3HFEF.js";
+import {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/database/userPreferenceRegister.ts
+var USER_PREFERENCE_NAMES = {
+  AUTHORITY_HOME: "authority_home",
+  DEFAULT_AGENT: "agent_default"
+};
+var nextRegisterUpdatedAt = (previousRecord) => {
+  const previousTimestamp = Math.max(
+    toTimestampMs(previousRecord?.updatedAt),
+    toTimestampMs(previousRecord?.createdAt)
+  );
+  return Math.max(Date.now(), previousTimestamp + 1);
+};
+var buildUserPreferenceRegisterRecord = ({
+  userId,
+  preferenceName,
+  value,
+  previousRecord
+}) => {
+  const updatedAt = nextRegisterUpdatedAt(previousRecord ?? void 0);
+  return {
+    type: "setting" /* SETTING */,
+    registerType: "user_preference",
+    preferenceName,
+    schemaVersion: 1,
+    userId,
+    value,
+    opId: ulid(),
+    createdAt: toTimestampMs(previousRecord?.createdAt) || updatedAt,
+    updatedAt
+  };
+};
+var readUserPreferenceRegisterValue = (record, preferenceName) => {
+  if (!record || typeof record !== "object") return void 0;
+  if (record.registerType !== "user_preference") return void 0;
+  if (record.preferenceName !== preferenceName) return void 0;
+  if (!("value" in record)) return void 0;
+  return record.value;
+};
+var buildDefaultAgentPreferenceRegisterRecord = ({
+  userId,
+  defaultAgentId,
+  previousRecord
+}) => buildUserPreferenceRegisterRecord({
+  userId,
+  preferenceName: USER_PREFERENCE_NAMES.DEFAULT_AGENT,
+  value: defaultAgentId,
+  previousRecord
+});
+
+// packages/app/settings/settingActions.ts
+var updateSettingsState = createAction(
+  "settings/_updateSettingsState"
+);
+var bumpLocalIntentEpoch = createAction("settings/_bumpLocalIntentEpoch");
+var recordSettingsWriteFailure = createAction(
+  "settings/_recordSettingsWriteFailure"
+);
+var recordServerAuthorityEcho = createAction(
+  "settings/_recordServerAuthorityEcho"
+);
+
+// packages/app/settings/accountSettingsWriteQueue.ts
+var queues = /* @__PURE__ */ new WeakMap();
+function enqueueAccountSettingsWrite(getState, accountId, write2) {
+  let byAccount = queues.get(getState);
+  if (!byAccount) {
+    byAccount = /* @__PURE__ */ new Map();
+    queues.set(getState, byAccount);
+  }
+  const previous = byAccount.get(accountId) ?? Promise.resolve();
+  const result = previous.catch(() => void 0).then(write2);
+  const tail = result.then(() => void 0, () => void 0);
+  byAccount.set(accountId, tail);
+  void tail.then(() => {
+    if (byAccount?.get(accountId) === tail) byAccount.delete(accountId);
+  });
+  return result;
+}
+
+// packages/app/settings/accountChatDisplayOwner.ts
+var import_react = __toESM(require_react());
+var DEFAULT_ACCOUNT_CHAT_DISPLAY_PREFERENCES = Object.freeze({
+  showThinking: true,
+  showScrollToTopButton: false,
+  showScrollToBottomButton: false
+});
+var createAccountChatDisplayOwner = () => {
+  let accountId = null;
+  let snapshot = DEFAULT_ACCOUNT_CHAT_DISPLAY_PREFERENCES;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => listeners.forEach((listener) => listener());
+  return {
+    getAccountId: () => accountId,
+    getSnapshot: () => snapshot,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setAccount: (nextAccountId) => {
+      if (accountId === nextAccountId) return;
+      accountId = nextAccountId;
+      snapshot = DEFAULT_ACCOUNT_CHAT_DISPLAY_PREFERENCES;
+      emit();
+    },
+    updateForAccount: (expectedAccountId, changes) => {
+      if (!expectedAccountId || expectedAccountId !== accountId) return false;
+      const next = { ...snapshot, ...changes };
+      if (next.showThinking === snapshot.showThinking && next.showScrollToTopButton === snapshot.showScrollToTopButton && next.showScrollToBottomButton === snapshot.showScrollToBottomButton) return true;
+      snapshot = Object.freeze(next);
+      emit();
+      return true;
+    }
+  };
+};
+var owners = /* @__PURE__ */ new WeakMap();
+function getAccountChatDisplayOwner(getState) {
+  let owner = owners.get(getState);
+  if (!owner) {
+    owner = createAccountChatDisplayOwner();
+    owners.set(getState, owner);
+  }
+  return owner;
+}
+function pickAccountChatDisplayPreferences(value) {
+  const result = {};
+  for (const key of ["showThinking", "showScrollToTopButton", "showScrollToBottomButton"]) {
+    if (typeof value[key] === "boolean") result[key] = value[key];
+  }
+  return result;
+}
+var omitAccountChatDisplayPreferences = (value) => {
+  const { showThinking: _thinking, showScrollToTopButton: _top, showScrollToBottomButton: _bottom, ...rest } = value;
+  return rest;
+};
+
+// packages/app/settings/dbActionThunks.ts
+var getDefaultSettingDbActionThunks = () => ({
+  readAndWait,
+  patch,
+  upsert,
+  write
+});
+var settingDbActionThunksOverrideKey = Symbol.for(
+  "bun-nolo.app.settings.dbActionThunksOverride"
+);
+var getSettingDbActionThunks = () => {
+  const globalOverride = globalThis[settingDbActionThunksOverrideKey];
+  return globalOverride ?? getDefaultSettingDbActionThunks();
+};
+
+// packages/app/settings/settingsRecord.ts
+var SETTINGS_RECORD_SCHEMA_VERSION = 1;
+var withSettingsRecordSchema = (changes) => ({
+  ...changes,
+  schemaVersion: SETTINGS_RECORD_SCHEMA_VERSION
+});
+
+// packages/app/settings/settingPersistence.ts
+var normalizeSettingChanges = (changes) => {
+  let normalizedChanges = omitKeys(changes, [
+    "preferredAnimationSet",
+    "createMenuOpenCount",
+    // 本地意图世代只活在 redux 状态里：既不能从服务端 record 写回，也不能写云。
+    "localIntentEpoch",
+    // 权威回显世代同理：纯本地世代标记，不入云端 record、不被远端回灌。
+    "serverAuthorityEchoSeq",
+    // 写失败状态同样是纯本地 observability：绝不进入云端 settings record。
+    "lastWriteFailure",
+    // Retired device appearance is never accepted by Redux, including legacy callers.
+    "themeName",
+    "themeMode",
+    "isDark",
+    "density",
+    "fontPreset"
+  ]);
+  if (hasOwn(normalizedChanges, "defaultAgentId")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      defaultAgentId: normalizeDefaultAgentIdSetting(
+        normalizedChanges.defaultAgentId
+      )
+    };
+  }
+  if (hasOwn(normalizedChanges, "defaultSpaceId")) {
+    normalizedChanges = omitKeys(normalizedChanges, [
+      "defaultSpaceId"
+    ]);
+  }
+  if (hasOwn(normalizedChanges, "userTonePreset")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      userTonePreset: normalizeTonePresetSetting(
+        normalizedChanges.userTonePreset
+      )
+    };
+  }
+  if (hasOwn(normalizedChanges, "knowledgeCaptureLevel")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      knowledgeCaptureLevel: normalizePolicyLevelSetting(
+        normalizedChanges.knowledgeCaptureLevel,
+        DEFAULT_USER_PREFERENCE_PROFILE.knowledgeCaptureLevel
+      )
+    };
+  }
+  if (hasOwn(normalizedChanges, "spaceContextLevel")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      spaceContextLevel: normalizePolicyLevelSetting(
+        normalizedChanges.spaceContextLevel,
+        DEFAULT_USER_PREFERENCE_PROFILE.spaceContextLevel
+      )
+    };
+  }
+  if (hasOwn(normalizedChanges, "autoApproveSelfUpdateFields")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      autoApproveSelfUpdateFields: normalizeAgentUpdateFieldList(
+        normalizedChanges.autoApproveSelfUpdateFields
+      )
+    };
+  }
+  if (hasOwn(normalizedChanges, "systemBuiltinSkills")) {
+    normalizedChanges = {
+      ...normalizedChanges,
+      systemBuiltinSkills: normalizeSystemBuiltinSkills(
+        normalizedChanges.systemBuiltinSkills,
+        DEFAULT_SYSTEM_AGENT_CAPABILITIES
+      )
+    };
+  }
+  return normalizedChanges;
+};
+var LOCAL_APPEARANCE_KEY_NAMES = [
+  "themeName",
+  "themeMode",
+  "isDark",
+  "density",
+  "fontPreset"
+];
+var GUEST_UPDATABLE_KEY_NAMES = [
+  "sidebarWidth"
+];
+var LOCAL_FIRST_APPEARANCE_KEYS = Object.freeze(
+  Object.fromEntries(
+    LOCAL_APPEARANCE_KEY_NAMES.map((key) => [key, true])
+  )
+);
+var GUEST_UPDATABLE_KEYS = Object.freeze(
+  Object.fromEntries(
+    GUEST_UPDATABLE_KEY_NAMES.map((key) => [key, true])
+  )
+);
+var isGuestUpdatableKey = (key) => key in GUEST_UPDATABLE_KEYS;
+var isLocalFirstAppearanceChange = (changes) => {
+  const keys = Object.keys(changes);
+  if (keys.length === 0) return false;
+  return keys.every(
+    (key) => isGuestUpdatableKey(key)
+  );
+};
+var stripRegisterBackedFieldsFromSettingsWrite = (changes) => {
+  return omitKeys(changes, [
+    "autoApproveCredits",
+    "defaultSpaceId",
+    "userAuthorityRegistry",
+    "preferredAnimationSet",
+    "createMenuOpenCount",
+    ...LOCAL_APPEARANCE_KEY_NAMES
+  ]);
+};
+var sanitizeStoredSettingsRecord = (settingsRecord) => {
+  if (!settingsRecord || typeof settingsRecord !== "object") {
+    return null;
+  }
+  const record = settingsRecord;
+  const sanitizedSettings = omitKeys(record, [
+    "autoApproveCredits",
+    "defaultSpaceId",
+    "schemaVersion",
+    "preferredAnimationSet",
+    ...LOCAL_APPEARANCE_KEY_NAMES
+  ]);
+  return Object.keys(sanitizedSettings).length > 0 ? sanitizedSettings : null;
+};
+var hydrateStoredSettings = ({
+  userId,
+  settingsRecord,
+  authorityHomeServer
+}) => {
+  const record = settingsRecord ?? {};
+  const resolvedDefaultAgentId = normalizeDefaultAgentIdSetting(record.defaultAgentId) ?? SYSTEM_DEFAULT_AGENT_ID;
+  const baseSettings = sanitizeStoredSettingsRecord(settingsRecord) ?? {};
+  const normalizedAuthorityHome = normalizeAuthorityHomeServerSetting(authorityHomeServer);
+  const existingRegistry = asRecordOrEmpty(
+    baseSettings.userAuthorityRegistry
+  );
+  const userAuthorityRegistry = userId && normalizedAuthorityHome ? { ...existingRegistry, [userId]: normalizedAuthorityHome } : existingRegistry;
+  const userAuthorityRegistryIsEmpty = Object.keys(userAuthorityRegistry).length === 0;
+  const hydratedSettings = {
+    ...baseSettings,
+    // 服务端独占字段：只读回显（缺失时沿用初始值 0，非法值按 0）
+    ...hasOwn(record, "autoApproveCredits") ? { autoApproveCredits: typeof record.autoApproveCredits === "number" && Number.isFinite(record.autoApproveCredits) && record.autoApproveCredits >= 0 ? record.autoApproveCredits : 0 } : {},
+    ...userAuthorityRegistryIsEmpty ? {} : { userAuthorityRegistry },
+    defaultAgentId: resolvedDefaultAgentId
+  };
+  return Object.keys(hydratedSettings).length > 0 ? hydratedSettings : null;
+};
+var SERVER_AUTHORITATIVE_SETTINGS_KEYS = [
+  "autoApproveCredits",
+  "userAuthorityRegistry"
+];
+var pickServerAuthoritativeSettings = (hydrated) => {
+  const picked = {};
+  for (const key of SERVER_AUTHORITATIVE_SETTINGS_KEYS) {
+    if (hasOwn(hydrated, key)) {
+      picked[key] = hydrated[key];
+    }
+  }
+  return picked;
+};
+var buildSettingsPersistencePlan = ({
+  userId,
+  currentSettings,
+  changes,
+  previousDefaultAgentRecord
+}) => {
+  const normalizedChanges = normalizeSettingChanges(changes);
+  const persistedChanges = stripRegisterBackedFieldsFromSettingsWrite(normalizedChanges);
+  const previousDefaultAgentId = normalizeDefaultAgentIdSetting(currentSettings.defaultAgentId) ?? SYSTEM_DEFAULT_AGENT_ID;
+  const nextDefaultAgentId = normalizeDefaultAgentIdSetting(normalizedChanges.defaultAgentId) ?? null;
+  const previousDefaultAgentValue = readUserPreferenceRegisterValue(
+    previousDefaultAgentRecord,
+    USER_PREFERENCE_NAMES.DEFAULT_AGENT
+  ) ?? null;
+  const defaultAgentRegisterWrite = hasOwn(normalizedChanges, "defaultAgentId") && previousDefaultAgentId !== (nextDefaultAgentId ?? SYSTEM_DEFAULT_AGENT_ID) && (!previousDefaultAgentRecord || previousDefaultAgentValue !== nextDefaultAgentId) ? {
+    customKey: createUserPreferenceKey.defaultAgent(userId),
+    data: buildDefaultAgentPreferenceRegisterRecord({
+      userId,
+      defaultAgentId: nextDefaultAgentId,
+      previousRecord: previousDefaultAgentRecord
+    })
+  } : null;
+  const settingsPatch = Object.keys(persistedChanges).length > 0 ? {
+    dbKey: createUserKey.settings(userId),
+    changes: withSettingsRecordSchema(
+      persistedChanges
+    )
+  } : null;
+  return {
+    normalizedChanges,
+    defaultAgentRegisterWrite,
+    settingsPatch
+  };
+};
+var getCachedDefaultAgentRegisterRecord = (getState, registerKey) => {
+  const record = getState().db.entities[registerKey];
+  if (!record || typeof record !== "object") return null;
+  return record;
+};
+var persistDefaultAgentRegister = async (dispatch, getState, userId, value) => {
+  const registerKey = createUserPreferenceKey.defaultAgent(userId);
+  let previousRecord = getCachedDefaultAgentRegisterRecord(getState, registerKey);
+  if (!previousRecord) {
+    previousRecord = await dispatch(
+      getSettingDbActionThunks().readAndWait(registerKey)
+    ).unwrap().catch(() => null);
+  }
+  const previousValue = readUserPreferenceRegisterValue(
+    previousRecord,
+    USER_PREFERENCE_NAMES.DEFAULT_AGENT
+  ) ?? null;
+  if (previousRecord && previousValue === value) {
+    return;
+  }
+  await dispatch(
+    getSettingDbActionThunks().write({
+      customKey: registerKey,
+      data: buildDefaultAgentPreferenceRegisterRecord({
+        userId,
+        defaultAgentId: value,
+        previousRecord
+      })
+    })
+  ).unwrap();
+};
+
+// packages/app/settings/settingsWriteRetry.ts
+var SETTINGS_WRITE_RETRY_BACKOFF_MS = 200;
+var SETTINGS_RECONCILE_DEADLINE_MS = 3e3;
+var delaySettingsWriteRetry = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var readLocalIntentEpoch = (getState) => {
+  const value = getState()?.settings?.localIntentEpoch;
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+};
+var SettingsWriteSupersededError = class extends Error {
+  constructor(message = "Settings write superseded by a newer local intent.") {
+    super(message);
+    this.name = "SettingsWriteSupersededError";
+  }
+};
+var isSettingsWriteSupersededError = (error) => error instanceof SettingsWriteSupersededError;
+var reconcileDeadlineOverride = null;
+var reconcileDeadlineMs = () => reconcileDeadlineOverride ?? SETTINGS_RECONCILE_DEADLINE_MS;
+var readSettingsAuthorityServer = (getState, accountId) => {
+  const registry = getState()?.settings?.userAuthorityRegistry;
+  if (!registry || typeof registry !== "object") return null;
+  const value = registry[accountId];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+};
+var readAuthoritativeSettingsRecord = async (dbKey, getState, accountId) => {
+  const authorityServer = readSettingsAuthorityServer(getState, accountId);
+  if (!authorityServer) return null;
+  let token;
+  try {
+    token = getRuntimeServerContext(getState()).currentToken || void 0;
+  } catch {
+    token = void 0;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), reconcileDeadlineMs());
+  try {
+    const remote = await fetchFromServer(
+      authorityServer,
+      dbKey,
+      token,
+      controller.signal
+    );
+    if (remote && typeof remote === "object" && Object.keys(remote).length > 0) {
+      return remote;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var authorityReaderOverride = null;
+var readSettingsAuthorityRecord = async (dbKey, getState, accountId) => {
+  const reader = authorityReaderOverride ?? readAuthoritativeSettingsRecord;
+  const read = Promise.resolve().then(() => reader(dbKey, getState, accountId)).catch(() => null);
+  const deadline = delaySettingsWriteRetry(reconcileDeadlineMs()).then(
+    () => null
+  );
+  return await Promise.race([read, deadline]);
+};
+var stableValueKey = (value) => {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "undefined";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableValueKey).join(",")}]`;
+  }
+  const record = value;
+  const entries = Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableValueKey(record[key])}`);
+  return `{${entries.join(",")}}`;
+};
+var isSameSettingValue = (a, b) => stableValueKey(a) === stableValueKey(b);
+var resolveSettingsWriteFailureAfterSuccess = ({
+  failure,
+  accountId,
+  intentKeys,
+  persistedKeys
+}) => {
+  if (!failure) return null;
+  if (failure.accountId !== accountId) return failure;
+  const covered = /* @__PURE__ */ new Set([...intentKeys, ...persistedKeys]);
+  const remainingKeys = failure.keys.filter((key) => !covered.has(key));
+  if (remainingKeys.length === 0) return null;
+  return {
+    ...failure,
+    keys: remainingKeys,
+    unresolvedKeys: failure.unresolvedKeys.filter((key) => !covered.has(key))
+  };
+};
+var describeSettingsWriteFailure = async ({
+  getState,
+  accountId,
+  intentEpoch,
+  intentKeys,
+  persistedKeys,
+  at
+}) => {
+  const base = {
+    accountId,
+    keys: [...intentKeys].sort(),
+    at,
+    reconciliation: "not-attempted",
+    unresolvedKeys: [...persistedKeys].sort()
+  };
+  if (readLocalIntentEpoch(getState) !== intentEpoch) return base;
+  const remoteRecord = await readSettingsAuthorityRecord(
+    createUserKey.settings(accountId),
+    getState,
+    accountId
+  );
+  if (readLocalIntentEpoch(getState) !== intentEpoch) return base;
+  const serverRecord = sanitizeStoredSettingsRecord(remoteRecord);
+  if (!serverRecord) {
+    return {
+      ...base,
+      reconciliation: "unavailable"
+    };
+  }
+  const localSettings = getState()?.settings ?? {};
+  const owner = getAccountChatDisplayOwner(getState);
+  const localValues = owner.getAccountId() === accountId ? { ...localSettings, ...owner.getSnapshot() } : localSettings;
+  const unresolvedKeys = persistedKeys.filter((key) => !isSameSettingValue(localValues[key], serverRecord[key])).sort();
+  return {
+    ...base,
+    reconciliation: unresolvedKeys.length === 0 ? "matched" : "mismatched",
+    unresolvedKeys
+  };
+};
+
+// packages/app/settings/settingThunks.ts
+var readServerAuthorityEchoSeq = (getState) => {
+  const value = getState()?.settings?.serverAuthorityEchoSeq;
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+};
+var latestChatHydrations = /* @__PURE__ */ new WeakMap();
+var getSettings = createAsyncThunk("settings/getSettings", async (_, { dispatch, getState }) => {
+  const userId = selectIdentityUserId(getState());
+  if (!userId) return null;
+  const session = getSessionGenerationForState(getState());
+  const hydration = {};
+  latestChatHydrations.set(getState, hydration);
+  const startLocalIntentEpoch = readLocalIntentEpoch(getState);
+  const startAuthorityEchoSeq = readServerAuthorityEchoSeq(getState);
+  const settingsKey = createUserKey.settings(userId);
+  const authorityHomeKey = createUserPreferenceKey.authorityHome(userId);
+  const [settingsRecord, authorityHomeRecord] = await Promise.all([
+    dispatch(getSettingDbActionThunks().readAndWait(settingsKey)).unwrap().catch(() => null),
+    dispatch(getSettingDbActionThunks().readAndWait(authorityHomeKey)).unwrap().catch(() => null)
+  ]);
+  if (selectIdentityUserId(getState()) !== userId || getSessionGenerationForState(getState()) !== session || latestChatHydrations.get(getState) !== hydration) return null;
+  const authorityHomeServer = readUserPreferenceRegisterValue(
+    authorityHomeRecord,
+    USER_PREFERENCE_NAMES.AUTHORITY_HOME
+  ) ?? null;
+  const hydrated = hydrateStoredSettings({
+    userId,
+    settingsRecord,
+    authorityHomeServer
+  });
+  if (hydrated) {
+    const normalizedPayload = normalizeSettingChanges(
+      hydrated
+    );
+    const { currentServer: _ignored, ...settingsToApply } = normalizedPayload;
+    if (selectIdentityUserId(getState()) !== userId || getSessionGenerationForState(getState()) !== session || latestChatHydrations.get(getState) !== hydration) return null;
+    const intentChanged = readLocalIntentEpoch(getState) !== startLocalIntentEpoch;
+    const echoChanged = readServerAuthorityEchoSeq(getState) !== startAuthorityEchoSeq;
+    const authoritative = pickServerAuthoritativeSettings(hydrated);
+    const {
+      autoApproveCredits: _ignoredCredits,
+      userAuthorityRegistry: _ignoredRegistry,
+      ...preferenceFields
+    } = settingsToApply;
+    const applied = {};
+    if (!intentChanged) Object.assign(applied, preferenceFields);
+    if (!echoChanged && hasOwn(authoritative, "autoApproveCredits")) {
+      applied.autoApproveCredits = authoritative.autoApproveCredits;
+    }
+    if (hasOwn(authoritative, "userAuthorityRegistry")) {
+      applied.userAuthorityRegistry = authoritative.userAuthorityRegistry;
+    }
+    if (intentChanged) {
+      if (Object.keys(applied).length > 0) {
+        dispatch(updateSettingsState(applied));
+      }
+      return null;
+    }
+    const owner = getAccountChatDisplayOwner(getState);
+    owner.setAccount(userId);
+    owner.updateForAccount(userId, pickAccountChatDisplayPreferences(preferenceFields));
+    dispatch(updateSettingsState(omitAccountChatDisplayPreferences(applied)));
+  }
+  return hydrated;
+});
+var persistSettingsChanges = createAsyncThunk("settings/persistSettingsChanges", async (changes, { dispatch, getState }) => {
+  const session = getSessionGenerationForState(getState());
+  const currentSettings = getState().settings;
+  const normalizedChanges = normalizeSettingChanges(changes);
+  const previousDefaultAgentId = normalizeDefaultAgentIdSetting(currentSettings.defaultAgentId) ?? SYSTEM_DEFAULT_AGENT_ID;
+  const userId = selectIdentityUserId(getState());
+  if (!userId) {
+    const hasAppearanceChanges = Object.keys(normalizedChanges).length > 0;
+    if (hasAppearanceChanges) {
+      if (!isLocalFirstAppearanceChange(normalizedChanges)) {
+        throw new Error("User not found for persisting settings.");
+      }
+    } else {
+      throw new Error("User not found for persisting settings.");
+    }
+    dispatch(bumpLocalIntentEpoch());
+    dispatch(updateSettingsState(normalizedChanges));
+    return normalizedChanges;
+  }
+  const persistencePlan = buildSettingsPersistencePlan({
+    userId,
+    currentSettings,
+    changes: normalizedChanges,
+    previousDefaultAgentRecord: null
+  });
+  if (selectIdentityUserId(getState()) !== userId) return {};
+  const owner = getAccountChatDisplayOwner(getState);
+  dispatch(bumpLocalIntentEpoch());
+  const intentEpoch = readLocalIntentEpoch(getState);
+  owner.setAccount(userId);
+  owner.updateForAccount(userId, pickAccountChatDisplayPreferences(persistencePlan.normalizedChanges));
+  dispatch(updateSettingsState(omitAccountChatDisplayPreferences(persistencePlan.normalizedChanges)));
+  const intentKeys = Object.keys(persistencePlan.normalizedChanges);
+  const persistedKeys = Object.keys(
+    persistencePlan.settingsPatch?.changes ?? {}
+  ).filter((key) => key !== "schemaVersion");
+  const isCurrentIntent = () => selectIdentityUserId(getState()) === userId && getSessionGenerationForState(getState()) === session && readLocalIntentEpoch(getState) === intentEpoch;
+  const performWrite = async () => {
+    if (!isCurrentIntent()) {
+      throw new SettingsWriteSupersededError();
+    }
+    const nextDefaultAgentId = normalizeDefaultAgentIdSetting(
+      persistencePlan.normalizedChanges.defaultAgentId
+    ) ?? null;
+    if (hasOwn(changes, "defaultAgentId") && previousDefaultAgentId !== (nextDefaultAgentId ?? SYSTEM_DEFAULT_AGENT_ID)) {
+      await persistDefaultAgentRegister(
+        dispatch,
+        getState,
+        userId,
+        nextDefaultAgentId
+      );
+    }
+    if (persistencePlan.settingsPatch) {
+      await dispatch(
+        getSettingDbActionThunks().upsert({
+          dbKey: persistencePlan.settingsPatch.dbKey,
+          data: persistencePlan.settingsPatch.changes
+        })
+      ).unwrap();
+    }
+  };
+  const settleSettingsWriteFailureAfterSuccess = () => {
+    if (!isCurrentIntent()) return;
+    const existing = getState()?.settings?.lastWriteFailure;
+    if (!existing) return;
+    const next = resolveSettingsWriteFailureAfterSuccess({
+      failure: existing,
+      accountId: userId,
+      intentKeys,
+      persistedKeys
+    });
+    if (next === existing) return;
+    dispatch(recordSettingsWriteFailure(next));
+  };
+  await enqueueAccountSettingsWrite(getState, userId, async () => {
+    let firstFailureAt = 0;
+    try {
+      await performWrite();
+      settleSettingsWriteFailureAfterSuccess();
+      return;
+    } catch (firstError) {
+      if (isSettingsWriteSupersededError(firstError)) return;
+      firstFailureAt = Date.now();
+      if (!isCurrentIntent()) return;
+      await delaySettingsWriteRetry(SETTINGS_WRITE_RETRY_BACKOFF_MS);
+      if (!isCurrentIntent()) return;
+      try {
+        await performWrite();
+        settleSettingsWriteFailureAfterSuccess();
+        return;
+      } catch (retryError) {
+        if (isSettingsWriteSupersededError(retryError)) return;
+        if (!isCurrentIntent()) return;
+        const failure = await describeSettingsWriteFailure({
+          getState,
+          accountId: userId,
+          intentEpoch,
+          intentKeys,
+          persistedKeys,
+          at: firstFailureAt
+        });
+        if (!isCurrentIntent()) return;
+        dispatch(recordSettingsWriteFailure(failure));
+        throw retryError;
+      }
+    }
+  });
+  return persistencePlan.normalizedChanges;
+});
+var setAccountChatDisplayPreferences = createAsyncThunk(
+  "settings/setAccountChatDisplayPreferences",
+  async (changes, { dispatch, getState }) => {
+    const userId = selectIdentityUserId(getState());
+    if (!userId) throw new Error("User not found for persisting settings.");
+    const owner = getAccountChatDisplayOwner(getState);
+    owner.setAccount(userId);
+    return dispatch(persistSettingsChanges({
+      ...owner.getSnapshot(),
+      ...pickAccountChatDisplayPreferences(changes)
+    })).unwrap();
+  }
+);
+var setSettings = createAsyncThunk(
+  "settings/setSettings",
+  async (changes, { dispatch }) => {
+    const forbidden = ["showThinking", "showScrollToTopButton", "showScrollToBottomButton"];
+    if (forbidden.some((key) => Object.prototype.hasOwnProperty.call(changes, key))) {
+      throw new Error("Chat display preferences must use setAccountChatDisplayPreferences.");
+    }
+    return dispatch(persistSettingsChanges(changes)).unwrap();
+  }
+);
+var setSidebarWidth = createAsyncThunk(
+  "settings/setSidebarWidth",
+  async (sidebarWidth, { dispatch }) => dispatch(setSettings({ sidebarWidth })).unwrap()
+);
+var toggleEnableReadCurrentSpace = createAsyncThunk(
+  "settings/toggleEnableReadCurrentSpace",
+  async (_, { dispatch, getState }) => {
+    const current = getState().settings.enableReadCurrentSpace;
+    return dispatch(
+      setSettings({
+        enableReadCurrentSpace: !current,
+        spaceContextLevel: current ? 1 : DEFAULT_USER_PREFERENCE_PROFILE.spaceContextLevel
+      })
+    ).unwrap();
+  }
+);
+var setEditorDefaultMode = createAsyncThunk(
+  "settings/setEditorDefaultMode",
+  async (mode, { dispatch }) => dispatch(setSettings({ editorDefaultMode: mode })).unwrap()
+);
+var setEditorLightCodeTheme = createAsyncThunk(
+  "settings/setEditorLightCodeTheme",
+  async (theme, { dispatch }) => dispatch(setSettings({ editorLightCodeTheme: theme })).unwrap()
+);
+var setEditorDarkCodeTheme = createAsyncThunk(
+  "settings/setEditorDarkCodeTheme",
+  async (theme, { dispatch }) => dispatch(setSettings({ editorDarkCodeTheme: theme })).unwrap()
+);
+var setEditorCodeTheme = createAsyncThunk(
+  "settings/setEditorCodeTheme",
+  async (theme, { dispatch }) => dispatch(
+    setSettings({
+      editorLightCodeTheme: theme,
+      editorDarkCodeTheme: theme
+    })
+  ).unwrap()
+);
+var toggleEditorWordCount = createAsyncThunk(
+  "settings/toggleEditorWordCount",
+  async (_, { dispatch, getState }) => {
+    const current = getState().settings.editorWordCountEnabled;
+    return dispatch(setSettings({ editorWordCountEnabled: !current })).unwrap();
+  }
+);
+var toggleEditorShortcut = createAsyncThunk(
+  "settings/toggleEditorShortcut",
+  async (key, { dispatch, getState }) => {
+    const currentShortcuts = getState().settings.editorShortcuts;
+    const newShortcuts = {
+      ...currentShortcuts,
+      [key]: !currentShortcuts[key]
+    };
+    return dispatch(setSettings({ editorShortcuts: newShortcuts })).unwrap();
+  }
+);
+var setEditorFontSize = createAsyncThunk(
+  "settings/setEditorFontSize",
+  async (fontSize, { dispatch }) => dispatch(setSettings({ editorFontSize: fontSize })).unwrap()
+);
+var toggleEditorAutoSave = createAsyncThunk(
+  "settings/toggleEditorAutoSave",
+  async (_, { dispatch, getState }) => {
+    const current = getState().settings.editorAutoSave;
+    return dispatch(setSettings({ editorAutoSave: !current })).unwrap();
+  }
+);
+var setEditorAutoSaveInterval = createAsyncThunk(
+  "settings/setEditorAutoSaveInterval",
+  async (interval, { dispatch }) => dispatch(setSettings({ editorAutoSaveInterval: interval })).unwrap()
+);
+var setGlobalPrompt = createAsyncThunk(
+  "settings/setGlobalPrompt",
+  async (prompt, { dispatch }) => dispatch(setSettings({ globalPrompt: prompt })).unwrap()
+);
+var setUserTonePreset = createAsyncThunk(
+  "settings/setUserTonePreset",
+  async (tone, { dispatch }) => dispatch(setSettings({ userTonePreset: tone })).unwrap()
+);
+var setKnowledgeCaptureLevel = createAsyncThunk(
+  "settings/setKnowledgeCaptureLevel",
+  async (level, { dispatch }) => dispatch(setSettings({ knowledgeCaptureLevel: level })).unwrap()
+);
+var setSpaceContextLevel = createAsyncThunk(
+  "settings/setSpaceContextLevel",
+  async (level, { dispatch }) => dispatch(
+    setSettings({
+      spaceContextLevel: level,
+      enableReadCurrentSpace: level > 1
+    })
+  ).unwrap()
+);
+var setAiRecentContentLimit = createAsyncThunk(
+  "settings/setAiRecentContentLimit",
+  async (limit, { dispatch }) => dispatch(setSettings({ aiRecentContentLimit: limit })).unwrap()
+);
+var setMaxExecutionTime = createAsyncThunk(
+  "settings/setMaxExecutionTime",
+  async (time, { dispatch }) => dispatch(setSettings({ maxExecutionTime: time })).unwrap()
+);
+var setDefaultAgentId = createAsyncThunk(
+  "settings/setDefaultAgentId",
+  async (agentId, { dispatch }) => dispatch(
+    setSettings({
+      defaultAgentId: resolveDefaultAgentIdSetting(agentId)
+    })
+  ).unwrap()
+);
+export {
+  getSettings,
+  setAccountChatDisplayPreferences,
+  setAiRecentContentLimit,
+  setDefaultAgentId,
+  setEditorAutoSaveInterval,
+  setEditorCodeTheme,
+  setEditorDarkCodeTheme,
+  setEditorDefaultMode,
+  setEditorFontSize,
+  setEditorLightCodeTheme,
+  setGlobalPrompt,
+  setKnowledgeCaptureLevel,
+  setMaxExecutionTime,
+  setSettings,
+  setSidebarWidth,
+  setSpaceContextLevel,
+  setUserTonePreset,
+  toggleEditorAutoSave,
+  toggleEditorShortcut,
+  toggleEditorWordCount,
+  toggleEnableReadCurrentSpace
+};