dsh-plugin-effort-declare 0.1.1 → 0.1.2

package/src/client/EffortDeclareSection.tsx

@@ -35,7 +35,7 @@ import { validateSaveDraft, type SchemaOps } from './schema-ops.ts'
 import type { EffortDeclareKey } from './locales.ts'
 import css from './effort-declare.module.css'
 
-export type InvalidationSource = 'settings' | 'directory'
+export type InvalidationSource = 'settings' | 'directory' | 'writable'
 
 export interface EffortDeclareSectionInjected {
   api: Pick<IApiClient, 'settings' | 'llm'>
@@ -165,18 +165,20 @@ function RouteCard(props: {
   draft: RouteDraft
   formats: readonly string[]
   writable: boolean
+  /** This card is the in-flight mutate — show “Saving…”. */
   busy: boolean
-  reloading: boolean
+  /** Namespace-level lock: any mutate, read-only, or first load. */
+  saveLocked: boolean
   notice: CardNotice | undefined
   t: (key: EffortDeclareKey) => string
   onChange: (draft: RouteDraft) => void
   onSave: (draft: RouteDraft) => void
   onCancel: (draft: RouteDraft) => void
 }): ReactNode {
-  const { draft, writable, busy, reloading, t, onChange } = props
+  const { draft, writable, busy, saveLocked, t, onChange } = props
   const noModels = draft.models.length === 0
   const editDisabled = !writable || busy || noModels
-  const saveLocked = editDisabled || reloading
+  const saveDisabled = saveLocked || noModels
   const formats = thinkingFormatChoices(props.formats, draft.compat.thinkingFormat)
   const summary = compatSummary(draft.compat)
   const sameWire = draft.compat.supportsReasoningEffort === false
@@ -302,7 +304,7 @@ function RouteCard(props: {
         <button
           type="button"
           className={css.primaryButton}
-          disabled={saveLocked || !dirty || clientError !== undefined}
+          disabled={saveDisabled || !dirty || clientError !== undefined}
           onClick={() => { props.onSave(draft) }}
         >
           {busy ? t('saving') : t('save')}
@@ -335,7 +337,7 @@ export function EffortDeclareSection(props: EffortDeclareSectionProps): ReactNod
       return
     }
     const generation = nextGeneration(generationRef)
-    setStatus('loading')
+    if (draftsRef.current.length === 0) setStatus('loading')
     setError('')
     void loadDrafts(api, describe, schema).then((result) => {
       if (!generationIsCurrent(generationRef, generation)) return
@@ -370,9 +372,14 @@ export function EffortDeclareSection(props: EffortDeclareSectionProps): ReactNod
   useEffect(() => {
     if (props.subscribeInvalidate === undefined) return undefined
     return props.subscribeInvalidate((source) => {
+      if (source === 'writable') {
+        const view = describe?.getSnapshot().view
+        if (view !== undefined) setWritable(view.writable)
+        return
+      }
       if (source === 'settings' || source === 'directory') reload(true)
     })
-  }, [props.subscribeInvalidate, reload])
+  }, [describe, props.subscribeInvalidate, reload])
 
   const patchNotice = (provider: string, notice: CardNotice | undefined): void => {
     setNotices(current => {
@@ -385,7 +392,10 @@ export function EffortDeclareSection(props: EffortDeclareSectionProps): ReactNod
 
   const save = async (draft: RouteDraft): Promise<void> => {
     if (api === undefined || describe === undefined || schema === undefined) return
-    if (status === 'loading' || busyRoute !== null) return
+    if (status === 'loading' || busyRoute !== null) {
+      patchNotice(draft.provider, { kind: 'error', text: t('saveBusy') })
+      return
+    }
     const blocking = draft.models
       .map(row => errorText(modelEffortError(row), t))
       .find(text => text !== undefined)
@@ -502,7 +512,7 @@ export function EffortDeclareSection(props: EffortDeclareSectionProps): ReactNod
                 formats={formats.length > 0 ? formats : []}
                 writable={writable}
                 busy={busyRoute === draft.provider}
-                reloading={status === 'loading'}
+                saveLocked={!writable || busyRoute !== null || status === 'loading'}
                 notice={notices[draft.provider]}
                 t={t}
                 onChange={(next) => {

package/src/client/README.en.md

@@ -17,8 +17,8 @@ Cross-plugin work uses Cordis services only (`connection`, `settingsScope`, `set
 
 | File | Role |
 | --- | --- |
-| [`index.ts`](./index.ts) | Registers zh/en copy, CSS (`ctx.effect` insert/remove), and `settings.section` (id `effort-declare`, order 12). Subscribes in `apply` to the mirror `describe.subscribe`, `settings/document-updated` (`llm-pi-ai` only), `llm/adapters-updated`, and `connection/reset`. `locale: NS` lets the framework inject `t`; `inject` only returns `api` / `describe` / `schema` / `subscribeInvalidate`. |
-| [`EffortDeclareSection.tsx`](./EffortDeclareSection.tsx) | Route cards, presets, Off tri-state, advanced protocol switches, save and cancel. |
+| [`index.ts`](./index.ts) | Registers zh/en copy, CSS (`ctx.effect` insert/remove), and `settings.section` (id `effort-declare`, order 12). `describe.subscribe` only syncs `writable` (it fires for every namespace, including this page’s own `acceptView`). Full reloads come from `settings/document-updated` (`llm-pi-ai` only), `llm/adapters-updated`, and `connection/reset`. `locale: NS` lets the framework inject `t`; `inject` only returns `api` / `describe` / `schema` / `subscribeInvalidate`. |
+| [`EffortDeclareSection.tsx`](./EffortDeclareSection.tsx) | Route cards, presets, Off tri-state, advanced protocol switches, save and cancel. Save is exclusive for the whole `llm-pi-ai` namespace; `busy` is “Saving…” on the in-flight card, `saveLocked` disables the others. A successful write folds `acceptView` + `applySaveSuccess` and does not full-reload. |
 | [`load-drafts.ts`](./load-drafts.ts) | Builds drafts from `llm.providers` + the settings mirror; drafts come from `user`, protocol classification may use `value`. `thinkingFormat` choices come only from the live schema union. |
 | [`locales.ts`](./locales.ts) | Copy namespace `plugin-effort-declare`. |
 | [`effort-declare.module.css`](./effort-declare.module.css) | `--dsw-alias-*` tokens only, so dark theme stays correct. |

package/src/client/README.md

@@ -17,8 +17,8 @@
 
 | 文件 | 说明 |
 | --- | --- |
-| [`index.ts`](./index.ts) | 注册 zh/en 文案、CSS（`ctx.effect` 插入/移除）与 `settings.section`（id `effort-declare`，order 12）。在 `apply` 里订阅镜像 `describe.subscribe`、`settings/document-updated`（仅 `llm-pi-ai`）、`llm/adapters-updated`、`connection/reset`。`locale: NS` 由框架注入 `t`，inject 只传 `api` / `describe` / `schema` / `subscribeInvalidate`。 |
-| [`EffortDeclareSection.tsx`](./EffortDeclareSection.tsx) | 路由卡片、预设、Off 三态、高级协议开关、保存与取消。 |
+| [`index.ts`](./index.ts) | 注册 zh/en 文案、CSS（`ctx.effect` 插入/移除）与 `settings.section`（id `effort-declare`，order 12）。`describe.subscribe` 只同步 `writable`（任意 namespace 都会触发，含自己的 `acceptView`）。真正重载来自 `settings/document-updated`（仅 `llm-pi-ai`）、`llm/adapters-updated`、`connection/reset`。`locale: NS` 由框架注入 `t`，inject 只传 `api` / `describe` / `schema` / `subscribeInvalidate`。 |
+| [`EffortDeclareSection.tsx`](./EffortDeclareSection.tsx) | 路由卡片、预设、Off 三态、高级协议开关、保存与取消。保存互斥到整个 `llm-pi-ai` namespace；`busy` 只给正在 mutate 的卡显示「保存中」，其它卡 `saveLocked`。自己写入成功走 `acceptView` + `applySaveSuccess`，不再全量 reload。 |
 | [`load-drafts.ts`](./load-drafts.ts) | 从 `llm.providers` + 镜像组装草稿；草稿取自 `user`，协议分类可用 `value`。`thinkingFormat` 可选项只来自现场 schema union。 |
 | [`locales.ts`](./locales.ts) | 文案 namespace `plugin-effort-declare`。 |
 | [`effort-declare.module.css`](./effort-declare.module.css) | 仅使用 `--dsw-alias-*` 设计令牌，保证暗色主题正确。 |

package/src/client/index.ts

@@ -66,8 +66,11 @@ export function apply(ctx: ClientContext): void {
     const emit = (source: InvalidationSource) => {
       for (const listener of invalidation) listener(source)
     }
+    // Mirror subscribe fires on every namespace (theme, locale, own acceptView).
+    // Only fold writable from that; llm-pi-ai document changes come from the
+    // Host event below so a dirty card is not treated as a conflict.
     const disposers = [
-      describe.subscribe(() => { emit('settings') }),
+      describe.subscribe(() => { emit('writable') }),
       ctx.remote.$on('settings/document-updated', (ns: string) => {
         if (ns !== LLM_PI_AI_NS) return
         emit('settings')

package/src/client/locales.ts

@@ -13,6 +13,7 @@ export type EffortDeclareKey =
   | 'readOnly'
   | 'save'
   | 'saving'
+  | 'saveBusy'
   | 'cancel'
   | 'saved'
   | 'conflict'
@@ -57,6 +58,7 @@ export const zh: Record<EffortDeclareKey, string> = {
   readOnly: '当前设置为只读，无法保存。',
   save: '保存',
   saving: '保存中…',
+  saveBusy: '另有路由正在保存，请稍候。',
   cancel: '取消',
   saved: '已保存。对话选择器会按新的能力声明显示 Effort 行。',
   conflict: '设置已被其他地方改过，请重新加载后再保存。',
@@ -100,6 +102,7 @@ export const en: Record<EffortDeclareKey, string> = {
   readOnly: 'Settings are read-only; saving is disabled.',
   save: 'Save',
   saving: 'Saving…',
+  saveBusy: 'Another route is saving. Wait, then save this card.',
   cancel: 'Cancel',
   saved: 'Saved. The composer Effort row follows this capability declaration.',
   conflict: 'Settings changed elsewhere. Reload, then save again.',

package/src/core/README.en.md

@@ -9,7 +9,7 @@
 
 Domain logic for the plugin: no React, no Cordis service instances. The settings page and Vitest both depend on these pure functions, so effort semantics can regress without booting DSH.
 
-Canonical level names and `thinkingFormat` values follow `@deepseek-ai/dsh-llm-pi-ai` (0.1.0-rc.8). A whitelist is pinned by tests; UI choices come only from the live schema union.
+Canonical level names and `thinkingFormat` values follow `@deepseek-ai/dsh-llm-pi-ai` (0.1.0-rc.8; 0.1.1-rc.2 uses the same level set). `thinkingFormat` is pinned to the live-schema snapshot in [`tests/fixtures/pi-ai-thinking-format-union.ts`](../../tests/fixtures/pi-ai-thinking-format-union.ts); effort keys stay a locally pinned whitelist. UI choices come only from the live schema union.
 
 ## What's in this directory
 
@@ -19,7 +19,7 @@ Canonical level names and `thinkingFormat` values follow `@deepseek-ai/dsh-llm-p
 | [`efforts.ts`](./efforts.ts) | `reasoningEfforts` read/write, Off tri-state, validation (empty object / Off-only / unknown keys return an error code, never throw). |
 | [`presets.ts`](./presets.ts) | DeepSeek, OpenAI, and on/off presets; each states all three dialect keys; spread onto existing model rows and route `compat`. |
 | [`path-ops.ts`](./path-ops.ts) | Same one-level key diff as the official Models page; `buildSaveOps` uses `settingsPath` and only submits that route’s full `models` table and dirty `compat` keys. |
-| [`drafts.ts`](./drafts.ts) | User-layer drafts, dirty aligned with pathOps, post-save revision bump, dirty merge, generation. |
+| [`drafts.ts`](./drafts.ts) | User-layer drafts, dirty aligned with pathOps, post-save revision. On refresh, latest user-layer model membership wins; unsaved `reasoningEfforts` (including a cleared key) overlay by id; `compat` is a per-key 3-way merge. Conflict only when a locally dirty field also moved in originals (revision-only bumps and sibling-card saves do not warn). |
 | [`paths.ts`](./paths.ts) | Nested reads; clones of objects and model tables (non-object rows skipped). |
 | [`filter.ts`](./filter.ts) | Which routes are editable: hand-declared `llm-pi-ai` + openai-completions; skip catalog and official DeepSeek. |
 | [`validate.ts`](./validate.ts) | Per-row `reasoningEfforts` validation. |

package/src/core/README.md

@@ -9,7 +9,7 @@
 
 本插件的领域逻辑：无 React、无 Cordis 服务实例。设置页与 Vitest 都只依赖这些纯函数，因此档位语义可以在不启动 DSH 的情况下回归。
 
-规范键名与 `thinkingFormat` 取值对齐 `@deepseek-ai/dsh-llm-pi-ai`（0.1.0-rc.8）。仓库内有测试钉白名单；UI 可选项只来自现场 schema union。
+规范键名与 `thinkingFormat` 取值对齐 `@deepseek-ai/dsh-llm-pi-ai`（0.1.0-rc.8；0.1.1-rc.2 档位集合相同）。`thinkingFormat` 由 [`tests/fixtures/pi-ai-thinking-format-union.ts`](../../tests/fixtures/pi-ai-thinking-format-union.ts) 钉现场 schema；档位键由测试钉本地白名单。UI 可选项只来自现场 schema union。
 
 ## 这个目录里有什么
 
@@ -19,7 +19,7 @@
 | [`efforts.ts`](./efforts.ts) | `reasoningEfforts` 读写、Off 三态、校验（空对象 / 只开 Off / 未知键返回错误码，不抛异常）。 |
 | [`presets.ts`](./presets.ts) | DeepSeek、OpenAI、仅开/关三套预设；每套对三个方言键都表态；spread 到已有模型行与路由 `compat`。 |
 | [`path-ops.ts`](./path-ops.ts) | 与官方模型页相同的一层键 diff；`buildSaveOps` 使用 `settingsPath`，只提交该路由的 `models` 整表和有差异的 `compat` 键。 |
-| [`drafts.ts`](./drafts.ts) | 用户层草稿、dirty 与 pathOps 一致、保存后 revision、脏卡合并、generation。 |
+| [`drafts.ts`](./drafts.ts) | 用户层草稿、dirty 与 pathOps 一致、保存后 revision。刷新时以最新用户层模型名单为成员真理，按 id 贴回未保存的 `reasoningEfforts`（含已清除=删键）；`compat` 按键三路合并。冲突仅当本地脏字段的 originals 也变了（只 bump revision 或别的卡保存不报）。 |
 | [`paths.ts`](./paths.ts) | 嵌套读取、对象与模型表的 clone（非对象行跳过）。 |
 | [`filter.ts`](./filter.ts) | 哪些路由可编辑：手工 `llm-pi-ai` + openai-completions；排除 catalog 与官方 DeepSeek。 |
 | [`validate.ts`](./validate.ts) | 对单行 `reasoningEfforts` 调用校验。 |

package/src/core/catalog.ts

@@ -3,9 +3,11 @@
  *
  * Levels match `@deepseek-ai/dsh-llm-pi-ai` catalog.ts `THINKING_LEVELS`.
  * Formats match `SUPPORTED_THINKING_FORMATS` in the same file (rc.8).
- * Tests pin these lists against llm-pi-ai. The settings page never offers
- * the handwritten thinkingFormat list as writable choices — only the live
- * schema union, plus a stored value that the union omitted.
+ * Tests pin these lists against a checked-in schema fixture
+ * (`tests/fixtures/pi-ai-thinking-format-union.ts`) and the local level
+ * whitelist. The settings page never offers the handwritten thinkingFormat
+ * list as writable choices — only the live schema union, plus a stored
+ * value that the union omitted.
  */
 
 /** Selectable reasoning levels, in pi-ai escalation order. */

package/src/core/drafts.ts

@@ -22,6 +22,16 @@ export interface RouteDraft {
   compatPresent: boolean
 }
 
+/** JSON-stable equality matching pathOps (key order included). */
+export function sliceEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+/** Whether two settings slices differ. */
+export function sliceChanged(before: unknown, after: unknown): boolean {
+  return !sliceEqual(before, after)
+}
+
 /** Build a draft from the stored user subtree (never from effective `value`). */
 export function routeDraftFromUserProfile(args: {
   provider: string
@@ -89,9 +99,132 @@ export function applySaveSuccess(
   })
 }
 
+function modelRowId(row: Record<string, unknown>): string {
+  return String(row.id)
+}
+
+function indexById(rows: readonly Record<string, unknown>[]): Map<string, Record<string, unknown>> {
+  const map = new Map<string, Record<string, unknown>>()
+  for (const row of rows) {
+    const id = modelRowId(row)
+    if (!map.has(id)) map.set(id, row)
+  }
+  return map
+}
+
+function effortsPresence(row: Record<string, unknown> | undefined): { present: boolean; value: unknown } {
+  if (row === undefined || !Object.hasOwn(row, 'reasoningEfforts')) {
+    return { present: false, value: undefined }
+  }
+  return { present: true, value: row.reasoningEfforts }
+}
+
+function effortsEqual(
+  left: { present: boolean; value: unknown },
+  right: { present: boolean; value: unknown },
+): boolean {
+  if (left.present !== right.present) return false
+  if (!left.present) return true
+  return sliceEqual(left.value, right.value)
+}
+
+function overlayLocalEfforts(
+  incomingRow: Record<string, unknown>,
+  prevRow: Record<string, unknown>,
+): Record<string, unknown> {
+  const next = structuredClone(incomingRow)
+  if (Object.hasOwn(prevRow, 'reasoningEfforts')) {
+    next.reasoningEfforts = structuredClone(prevRow.reasoningEfforts)
+  } else {
+    delete next.reasoningEfforts
+  }
+  return next
+}
+
+function objectKeyChanged(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+  key: string,
+): boolean {
+  const leftHas = Object.hasOwn(left, key)
+  const rightHas = Object.hasOwn(right, key)
+  if (leftHas !== rightHas) return true
+  if (!leftHas) return false
+  return sliceChanged(left[key], right[key])
+}
+
+/**
+ * Membership follows the latest user-layer models list (Models page add/delete).
+ * Local unsaved `reasoningEfforts` (including a cleared key) overlay by id.
+ */
+export function mergeModelsById(args: {
+  prevModels: readonly Record<string, unknown>[]
+  prevOriginal: readonly Record<string, unknown>[]
+  incomingModels: readonly Record<string, unknown>[]
+  incomingOriginal: readonly Record<string, unknown>[]
+}): { models: Record<string, unknown>[]; conflicted: boolean } {
+  const prevById = indexById(args.prevModels)
+  const prevOrigById = indexById(args.prevOriginal)
+  const incomingOrigById = indexById(args.incomingOriginal)
+  const incomingIds = new Set(args.incomingModels.map(modelRowId))
+  let conflicted = false
+
+  const models = args.incomingModels.map((incomingRow) => {
+    const id = modelRowId(incomingRow)
+    const prevRow = prevById.get(id)
+    if (prevRow === undefined) return structuredClone(incomingRow)
+    const prevOrig = prevOrigById.get(id)
+    const localDirty = !effortsEqual(effortsPresence(prevRow), effortsPresence(prevOrig))
+    if (!localDirty) return structuredClone(incomingRow)
+    const incomingOrig = incomingOrigById.get(id)
+    if (!effortsEqual(effortsPresence(prevOrig), effortsPresence(incomingOrig))) {
+      conflicted = true
+    }
+    return overlayLocalEfforts(incomingRow, prevRow)
+  })
+
+  for (const [id, prevRow] of prevById) {
+    if (incomingIds.has(id)) continue
+    const prevOrig = prevOrigById.get(id)
+    if (effortsEqual(effortsPresence(prevRow), effortsPresence(prevOrig))) continue
+    if (!effortsEqual(effortsPresence(prevOrig), effortsPresence(incomingOrigById.get(id)))) {
+      conflicted = true
+    }
+  }
+
+  return { models, conflicted }
+}
+
 /**
- * Apply a freshly loaded table. Dirty cards keep models/compat; originals and
- * revision follow the incoming snapshot so a later save is against the new user layer.
+ * Three-way compat merge: locally changed keys stay local; everything else
+ * follows incoming. Conflict only when a locally dirty key also moved in originals.
+ */
+export function mergeCompat(args: {
+  prev: Record<string, unknown>
+  prevOriginal: Record<string, unknown>
+  incoming: Record<string, unknown>
+  incomingOriginal: Record<string, unknown>
+}): { compat: Record<string, unknown>; conflicted: boolean } {
+  if (!sliceChanged(args.prev, args.prevOriginal)) {
+    return { compat: cloneObject(args.incoming), conflicted: false }
+  }
+  const compat = cloneObject(args.incoming)
+  let conflicted = false
+  const keys = new Set([...Object.keys(args.prev), ...Object.keys(args.prevOriginal)])
+  for (const key of keys) {
+    if (!objectKeyChanged(args.prev, args.prevOriginal, key)) continue
+    if (objectKeyChanged(args.prevOriginal, args.incomingOriginal, key)) conflicted = true
+    if (Object.hasOwn(args.prev, key)) compat[key] = structuredClone(args.prev[key])
+    else delete compat[key]
+  }
+  return { compat, conflicted }
+}
+
+/**
+ * Apply a freshly loaded table. Membership and metadata follow incoming;
+ * unsaved reasoningEfforts / dirty compat keys overlay by id. Conflict only
+ * when a locally dirty field also changed in originals (revision-only bumps
+ * and sibling-card saves do not warn).
  */
 export function mergeLoadedDrafts(
   current: readonly RouteDraft[],
@@ -103,13 +236,27 @@ export function mergeLoadedDrafts(
   const drafts = incoming.map((next) => {
     const prev = currentByProvider.get(next.provider)
     if (prev === undefined || !options.preserveDirty || !draftDirty(prev)) return next
-    conflicted.push(next.provider)
+    const modelsMerge = mergeModelsById({
+      prevModels: prev.models,
+      prevOriginal: prev.originalModels,
+      incomingModels: next.models,
+      incomingOriginal: next.originalModels,
+    })
+    const compatMerge = mergeCompat({
+      prev: prev.compat,
+      prevOriginal: prev.originalCompat,
+      incoming: next.compat,
+      incomingOriginal: next.originalCompat,
+    })
+    if (modelsMerge.conflicted || compatMerge.conflicted) conflicted.push(next.provider)
     return {
-      ...prev,
+      provider: next.provider,
       displayName: next.displayName,
       settingsPath: next.settingsPath,
       revision: next.revision,
+      models: modelsMerge.models,
       originalModels: cloneModels(next.originalModels),
+      compat: compatMerge.compat,
       originalCompat: cloneObject(next.originalCompat),
       compatPresent: next.compatPresent,
     }