dsh-advisor-plugin 0.2.1

package/src/client/controller.ts

@@ -0,0 +1,399 @@
+/**
+ * controller —— Advisor 设置卡片的暂存编辑器（浏览器半）。
+ *
+ * 数据面（均为 rc.6 客户端服务）：
+ *   - 设置：ctx.settingsScope.bind({namespace:'advisor'}) —— 快照/订阅/
+ *     set(field, value) 逐字段写入（写的是用户层 ~/.dsh/settings.yaml）
+ *   - 模型目录：ctx.get('connection').api.llm.models({}) —— 枚举 DSH 已
+ *     配置的全部 provider 与模型，正是"选择 DSH 已经配置好的模型"的数据源
+ *
+ * 暂存语义：改动先进 draft，save 一次性逐字段写入；discard 丢掉 draft。
+ * 类型上不依赖官方 client 包的模块增强（rc 阶段漂移面大），
+ * 连接 API 在边界做一次结构化收窄——白皮书第 3/4 章的边界放宽纪律。
+ */
+
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import { createSnapshotStore, type SnapshotStore } from './store.js'
+
+/**
+ * 设置作用域的结构化契约（本地声明，跨 dsh 版本无关——rc.6/0.1.1 的类型
+ * 宿主在 dsh-client-runtime，0.1.2 在 dsh-client-ui-settings，追版本不如
+ * 只声明自己用到的面）。bind 边界做一次收窄。
+ */
+export interface AdvisorSettingsScope<T> {
+  getSnapshot(): { status: 'loading' | 'ready' | 'unavailable', value: T | undefined, writable: boolean }
+  subscribe(listener: () => void): () => void
+  set(field: string, value: unknown): Promise<void>
+}
+
+/** 模型目录的一行（llm.models wire schema 的结构子集） */
+export interface CatalogModel {
+  id: string
+  name: string
+  /** 该模型声明的推理档位；null/缺省 = 未声明（配置时不过滤，靠 host 自动降级兜底） */
+  reasoning?: { efforts: readonly { id: string, name: string }[] | null } | null
+}
+
+export interface CatalogGroup {
+  id: string
+  name: string
+  models: readonly CatalogModel[]
+}
+
+interface ModelCatalogResponse {
+  groups: CatalogGroup[]
+  failures: readonly { id: string }[]
+}
+
+/** connection 服务的 llm 面结构收窄（唯一边界） */
+interface ConnectionLlApi {
+  llm: {
+    models: (payload: Record<string, never>, signal?: AbortSignal) => Promise<
+      | { result: { ok: true, value: ModelCatalogResponse } }
+      | { result: { ok: false } }
+    >
+  }
+}
+
+/** 一条精确的 provider/model 路由 + 档位 */
+export interface AdvisorRoute {
+  provider: string
+  model: string
+  effort: string
+}
+
+/** 卡片暂存的完整段值（路由 + 档位 + 巡逻设置） */
+type SectionDraft = Required<AdvisorSection>
+
+/** 目录里的一行（含与生效路由的 join 结果） */
+export interface AdvisorCandidate {
+  key: string
+  provider: string
+  model: string
+  providerName: string
+  modelName: string
+  available: boolean
+  selected: boolean
+  /** 该模型支持的推理档位（从目录 reasoning 声明提取）；undefined = 未声明 */
+  effortLevels?: readonly string[]
+}
+
+export interface AdvisorCardState {
+  /** 设置命名空间就绪 */
+  available: boolean
+  writable: boolean
+  saving: boolean
+  failed: boolean
+  dirty: boolean
+  catalogStatus: 'idle' | 'loading' | 'ready' | 'error'
+  catalogPartial: boolean
+  /** 生效值（draft 优先，其次已保存值） */
+  effective: AdvisorRoute
+  /** 巡逻模式的生效值（同 draft 优先） */
+  patrol: { enabled: boolean, everySteps: number, immuneTurns: number, investigate: boolean }
+  /** 当前路由的推理档位支持面（目录声明） */
+  efforts: { known: boolean, levels: readonly string[] }
+  groups: readonly { id: string, name: string, candidates: readonly AdvisorCandidate[] }[]
+}
+
+export interface AdvisorCardFace {
+  hooks: { advisorCard: SnapshotStore<AdvisorCardState> }
+  pickRoute: (key: string) => void
+  setEffort: (effort: string) => void
+  togglePatrol: () => void
+  setPatrolEverySteps: (steps: number) => void
+  setPatrolImmuneTurns: (n: number) => void
+  toggleInvestigate: () => void
+  save: () => void
+  discard: () => void
+  retryCatalog: () => void
+}
+
+function routeKey(provider: string, model: string): string {
+  return `${provider}\u0000${model}`
+}
+
+/** 目录 + 生效路由 → 分组候选行（纯函数；已保存但目录外路由以不可用行展示） */
+export function buildCandidates(
+  groups: readonly CatalogGroup[],
+  effective: AdvisorRoute,
+): { groups: { id: string, name: string, candidates: AdvisorCandidate[] }[], stale: boolean } {
+  const selectedKey = effective.provider === '' || effective.model === '' ? undefined : routeKey(effective.provider, effective.model)
+  const seen = new Set<string>()
+  const out = groups.map(group => ({
+    id: group.id,
+    name: group.name,
+    candidates: group.models.map(model => {
+      const key = routeKey(group.id, model.id)
+      seen.add(key)
+      const declared = model.reasoning?.efforts
+      return {
+        key,
+        provider: group.id,
+        model: model.id,
+        providerName: group.name,
+        modelName: model.name,
+        available: true,
+        selected: key === selectedKey,
+        ...(declared === undefined || declared === null ? {} : { effortLevels: declared.map(e => e.id) }),
+      }
+    }),
+  }))
+  let stale = false
+  // 已保存但目录中不存在的路由：以"不可用"行展示，保证用户能取消选择
+  if (selectedKey !== undefined && !seen.has(selectedKey)) {
+    stale = true
+    out.push({
+      id: effective.provider,
+      name: effective.provider,
+      candidates: [{
+        key: selectedKey,
+        provider: effective.provider,
+        model: effective.model,
+        providerName: effective.provider,
+        modelName: effective.model,
+        available: false,
+        selected: true,
+      }],
+    })
+  }
+  return { groups: out, stale }
+}
+
+/** 当前生效路由的档位支持面（纯函数）：known=false 表示目录未声明，不做过滤 */
+export function currentEffortSupport(
+  groups: readonly CatalogGroup[],
+  route: AdvisorRoute,
+): { known: boolean, levels: readonly string[] } {
+  if (route.provider === '' || route.model === '') return { known: false, levels: [] }
+  const declared = groups
+    .find(g => g.id === route.provider)
+    ?.models.find(m => m.id === route.model)
+    ?.reasoning?.efforts
+  if (declared === undefined || declared === null) return { known: false, levels: [] }
+  return { known: true, levels: declared.map(e => e.id) }
+}
+
+export interface AdvisorSection {
+  provider?: string
+  model?: string
+  effort?: string
+  patrolEnabled?: boolean
+  patrolEverySteps?: number
+  patrolImmuneTurns?: number
+  investigate?: boolean
+}
+
+export class AdvisorCardController {
+  private catalogGroups: readonly CatalogGroup[] = []
+  private catalogStatus: AdvisorCardState['catalogStatus'] = 'idle'
+  private catalogPartial = false
+  private draft: SectionDraft | undefined
+  private saving = false
+  private failed = false
+  private disposed = false
+  private catalogGeneration = 0
+  private readonly store: SnapshotStore<AdvisorCardState>
+  private readonly unsubscribe: () => void
+
+  constructor(
+    private readonly scope: AdvisorSettingsScope<AdvisorSection>,
+    private readonly ctx: ClientContext,
+  ) {
+    this.store = createSnapshotStore<AdvisorCardState>(this.projection())
+    this.unsubscribe = scope.subscribe(() => {
+      if (!this.saving) this.publish()
+    })
+    if (this.catalogStatus === 'idle') void this.loadCatalog()
+  }
+
+  dispose(): void {
+    this.disposed = true
+    this.catalogGeneration += 1
+    this.unsubscribe()
+  }
+
+  inject(): AdvisorCardFace {
+    return {
+      hooks: { advisorCard: this.store },
+      pickRoute: (key) => this.pickRoute(key),
+      setEffort: (effort) => this.setEffort(effort),
+      togglePatrol: () => this.togglePatrol(),
+      setPatrolEverySteps: (steps) => this.setPatrolEverySteps(steps),
+      setPatrolImmuneTurns: (n) => this.setPatrolImmuneTurns(n),
+      toggleInvestigate: () => this.toggleInvestigate(),
+      save: () => { void this.save() },
+      discard: () => this.discard(),
+      retryCatalog: () => { void this.loadCatalog() },
+    }
+  }
+
+  private saved(): SectionDraft {
+    const value = this.scope.getSnapshot().value
+    return {
+      provider: value?.provider ?? '',
+      model: value?.model ?? '',
+      effort: value?.effort ?? '',
+      patrolEnabled: value?.patrolEnabled ?? true,
+      patrolEverySteps: value?.patrolEverySteps ?? 6,
+      patrolImmuneTurns: value?.patrolImmuneTurns ?? 3,
+      investigate: value?.investigate ?? true,
+    }
+  }
+
+  private savedPatrol(): { enabled: boolean, everySteps: number } {
+    const saved = this.saved()
+    return { enabled: saved.patrolEnabled !== false, everySteps: saved.patrolEverySteps ?? 6 }
+  }
+
+  private effective(): SectionDraft {
+    return this.draft ?? this.saved()
+  }
+
+  private pickRoute(key: string): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    const all = this.catalogGroups.flatMap(g => g.models.map(m => ({ provider: g.id, model: m.id })))
+    const hit = all.find(r => routeKey(r.provider, r.model) === key)
+    const base = this.effective()
+    const currentKey = base.provider === '' || base.model === '' ? undefined : routeKey(base.provider, base.model)
+    // 再次点击已选路由 = 取消选择（advisor 回到未武装态）；目录外 stale 行同理
+    if (currentKey === key) {
+      this.draft = { ...base, provider: '', model: '' }
+    } else if (hit !== undefined) {
+      let draft: SectionDraft = { ...base, provider: hit.provider, model: hit.model }
+      // 档位校验：新模型已声明支持面且当前档位不在其中 → 自动清空（走模型默认）
+      const support = currentEffortSupport(this.catalogGroups, draft)
+      if (support.known && draft.effort !== '' && !support.levels.includes(draft.effort)) {
+        console.log(`[dsh-advisor] 档位 ${draft.effort} 不被 ${draft.provider}/${draft.model} 支持，已自动清空`)
+        draft = { ...draft, effort: '' }
+      }
+      this.draft = draft
+    }
+    this.failed = false
+    this.publish()
+  }
+
+  private setEffort(effort: string): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    // 档位校验：已声明支持面时只接受其中的档位
+    const support = currentEffortSupport(this.catalogGroups, this.effective())
+    if (support.known && effort !== '' && !support.levels.includes(effort)) return
+    this.draft = { ...this.effective(), effort }
+    this.failed = false
+    this.publish()
+  }
+
+  private togglePatrol(): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    const current = this.effective()
+    this.draft = { ...current, patrolEnabled: !(current.patrolEnabled ?? true) }
+    this.failed = false
+    this.publish()
+  }
+
+  private setPatrolEverySteps(steps: number): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    const bounded = Number.isFinite(steps) ? Math.min(500, Math.max(2, Math.round(steps))) : 6
+    this.draft = { ...this.effective(), patrolEverySteps: bounded }
+    this.failed = false
+    this.publish()
+  }
+
+  private setPatrolImmuneTurns(n: number): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    const bounded = Number.isFinite(n) ? Math.min(20, Math.max(0, Math.round(n))) : 3
+    this.draft = { ...this.effective(), patrolImmuneTurns: bounded }
+    this.failed = false
+    this.publish()
+  }
+
+  private toggleInvestigate(): void {
+    if (!this.scope.getSnapshot().writable || this.saving) return
+    const current = this.effective()
+    this.draft = { ...current, investigate: !(current.investigate ?? true) }
+    this.failed = false
+    this.publish()
+  }
+
+  private discard(): void {
+    if (this.saving) return
+    this.draft = undefined
+    this.failed = false
+    this.publish()
+  }
+
+  private async save(): Promise<void> {
+    const desired = this.draft
+    if (this.disposed || desired === undefined || this.saving || !this.scope.getSnapshot().writable) return
+    this.saving = true
+    this.failed = false
+    this.publish()
+    try {
+      // rc.6 scope 是逐字段写：五个字段顺序写入（'' 也写，保证旧值被清掉）
+      await this.scope.set('provider', desired.provider)
+      await this.scope.set('model', desired.model)
+      await this.scope.set('effort', desired.effort)
+      await this.scope.set('patrolEnabled', desired.patrolEnabled ?? true)
+      await this.scope.set('patrolEverySteps', desired.patrolEverySteps ?? 6)
+      await this.scope.set('patrolImmuneTurns', desired.patrolImmuneTurns ?? 3)
+      await this.scope.set('investigate', desired.investigate ?? true)
+      this.draft = undefined
+    } catch {
+      this.failed = true
+    }
+    this.saving = false
+    this.publish()
+  }
+
+  private async loadCatalog(): Promise<void> {
+    if (this.disposed || this.catalogStatus === 'loading') return
+    const generation = this.catalogGeneration
+    this.catalogStatus = 'loading'
+    this.catalogPartial = false
+    this.publish()
+    try {
+      const connection = this.ctx.get('connection') as unknown as { api: ConnectionLlApi }
+      const response = await connection.api.llm.models({})
+      if (generation !== this.catalogGeneration) return
+      if (response.result.ok) {
+        this.catalogGroups = response.result.value.groups
+        this.catalogPartial = response.result.value.failures.length > 0
+        this.catalogStatus = 'ready'
+      } else {
+        this.catalogStatus = 'error'
+      }
+    } catch {
+      if (generation !== this.catalogGeneration) return
+      this.catalogStatus = 'error'
+    }
+    this.publish()
+  }
+
+  private projection(): AdvisorCardState {
+    const snapshot = this.scope.getSnapshot()
+    const effective = this.effective()
+    const built = buildCandidates(this.catalogGroups, effective)
+    return {
+      available: snapshot.status === 'ready',
+      writable: snapshot.writable,
+      saving: this.saving,
+      failed: this.failed,
+      dirty: this.draft !== undefined,
+      catalogStatus: this.catalogStatus,
+      catalogPartial: this.catalogPartial,
+      effective,
+      patrol: {
+        enabled: effective.patrolEnabled ?? true,
+        everySteps: effective.patrolEverySteps ?? 6,
+        immuneTurns: effective.patrolImmuneTurns ?? 3,
+        investigate: effective.investigate ?? true,
+      },
+      efforts: currentEffortSupport(this.catalogGroups, effective),
+      groups: built.groups,
+    }
+  }
+
+  private publish(): void {
+    this.store.set(this.projection())
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,100 @@
+/**
+ * dsh-advisor —— 浏览器半（client half）入口。
+ *
+ * 职责：把 Advisor 设置卡片注册进设置页"插件"栏的 `settings.plugin.item`
+ * 槽（rc.6 形态：id='advisor' 的列表项卡片）。卡片数据 = 'advisor' 设置
+ * 作用域 + connection.api.llm.models 模型目录。
+ *
+ * 依赖（dsh.client.inject）：locale / ui-settings / connection / runtime /
+ * ui-settings-plugins（槽类型归属包）——全部由 web 应用提供；本包零
+ * 运行时值导入（@deepseek-ai/* 只做类型导入，react 走平台 jsx-runtime）。
+ */
+
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-client-locale/client'
+import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
+import type {} from '@deepseek-ai/dsh-client-ui-settings-plugins/client'
+// 0.1.2 起 slots 的 Context/SlotMap 类型增强住在 dsh-client-ui-cordis；
+// ui-tool 携带 tool.call.toolview 槽契约（key 域对插件自有工具开放）
+import type {} from '@deepseek-ai/dsh-client-ui-cordis/client'
+import type {} from '@deepseek-ai/dsh-client-ui-tool/client'
+import type {} from '@deepseek-ai/dsh-client-ui-slots'
+import { AdvisorCard } from './AdvisorCard.js'
+import { AdvisorToolRow } from './AdvisorToolRow.js'
+import { PatrolNodeView } from './PatrolNodeView.js'
+import { AdvisorCardController, type AdvisorSection, type AdvisorSettingsScope } from './controller.js'
+import type { ConversationEventsService } from './patrol-chat.js'
+import { patrolChatDefinition } from './patrol-chat.js'
+import { en, zh, type LocaleKey } from './locales.js'
+
+// 声明本插件的 locale 命名空间（值类型 = 文案键联合，官方同款姿势）
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface LocaleNamespaceMap {
+    'dsh-advisor.card': LocaleKey
+  }
+}
+
+// conversationEvents：0.1.1 客户端会话事件→聊天节点 Definition 注册面（巡逻
+// 卡片的物化通道）——cordis 要求先在 inject 声明才能在 ctx 上访问
+export const inject = ['slots', 'locale', 'connection', 'settingsScope', 'conversationEvents']
+
+const NS = 'dsh-advisor.card'
+
+export function apply(ctx: ClientContext): void {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-advisor: card dictionaries')
+
+  // bind 边界结构收窄（官方 SettingsScope 类型宿主随版本漂移，见 controller.ts 注释）
+  const scope = ctx.settingsScope.bind({ namespace: 'advisor' }) as unknown as AdvisorSettingsScope<AdvisorSection>
+  const controller = new AdvisorCardController(scope, ctx)
+  ctx.effect(() => () => { controller.dispose() }, 'dsh-advisor: settings card')
+
+  ctx.slots.inject('settings.plugin.item', function* () {
+    // 跨版本兼容：rc.6 用 options.id 标识列表项，0.1.1+ 用 options.key——
+    // 两个都传，各自读各自的（多余属性被忽略）；类型在边界放宽
+    yield ctx.slots.register({
+      name: 'settings.plugin.item',
+      key: 'advisor',
+      id: 'advisor',
+      order: 30,
+      locale: NS,
+      inject: () => {
+        const t = ctx.locale.bind(NS) as (key: LocaleKey) => string
+        return { ...controller.inject(), t }
+      },
+    } as never, AdvisorCard)
+  })
+
+  // advisor 工具的专属会话行（keyed 槽按工具名派发，官方对插件自有
+  // 工具开放的渲染定制点）：🧭 标题 + 状态徽标 + 可展开的建议全文
+  ctx.slots.inject('tool.call.toolview', function* () {
+    yield ctx.slots.register({
+      name: 'tool.call.toolview',
+      key: 'advisor',
+      locale: NS,
+      inject: () => ({ t: ctx.locale.bind(NS) as (key: LocaleKey) => string }),
+    } as never, AdvisorToolRow)
+  })
+
+  // 巡逻裁决卡片：conversationEvents 自定义 Definition 把 log-only 的
+  // 裁决事件物化为 kind 'advisor-patrol' 聊天节点，keyed 槽按 kind 派发
+  // 到本插件的 🧭 卡片（ON-TRACK 不写事件，天然不出卡片）。整个注册包
+  // 在 try/catch 里——可观测性增强绝不拖垮设置卡片与工具行
+  try {
+    const events = (ctx as unknown as { conversationEvents?: ConversationEventsService }).conversationEvents
+    if (events !== undefined) {
+      ctx.effect(() => events.register(patrolChatDefinition()), 'dsh-advisor: patrol chat definition')
+      ctx.slots.inject('conversation.chat.node', function* () {
+        yield ctx.slots.register({
+          name: 'conversation.chat.node',
+          key: 'advisor-patrol',
+          locale: NS,
+          inject: () => ({ t: ctx.locale.bind(NS) as (key: LocaleKey) => string }),
+        } as never, PatrolNodeView)
+      })
+    } else {
+      console.warn('[dsh-advisor] 当前 UI 未提供 conversationEvents 服务，巡逻卡片不可用（裁决仍会写日志与注入）')
+    }
+  } catch (error) {
+    console.warn('[dsh-advisor] 巡逻卡片注册失败（不影响其余功能）：', error)
+  }
+}

package/src/client/locales.ts

@@ -0,0 +1,105 @@
+/**
+ * locales —— Advisor 设置卡片的 zh/en 文案。
+ */
+
+export const zh = {
+  title: 'Advisor 审查模型',
+  description: '执行模型卡住/做重大决策/宣告完成前，可调用零参数的 advisor() 工具升级咨询该审查模型，拿回计划、纠正或停止信号。整段会话每次调用都会转发给它——升级不免费。',
+  armed: '当前审查模型',
+  off: '未选择——advisor 工具对模型隐藏（零提示词成本）',
+  offCurrent: '未选择',
+  choose: '选择一个 DSH 已配置的模型：',
+  loading: '正在加载模型目录…',
+  loadFailed: '模型目录加载失败',
+  retry: '重试',
+  partial: '部分 provider 的模型列表获取失败，列表可能不完整。',
+  empty: '没有可配置的模型——请先在 设置 → 模型 里配置 provider。',
+  effort: '推理档位',
+  effortDefault: '（模型默认）',
+  effortHint: '留空走模型默认；该模型未声明支持档位——若配置的档位不被支持，插件会自动降级为默认档（日志可见）。',
+  effortHintKnown: '只列出该模型声明支持的档位；留空走模型默认。',
+  unavailable: '（已配置的路由不在当前模型目录中）',
+  save: '保存',
+  saving: '保存中…',
+  discard: '放弃更改',
+  saved: '已保存',
+  saveFailed: '保存失败，请重试',
+  readonly: '设置文档只读，无法在此修改。',
+  patrolTitle: '巡逻模式（自动检测跑偏）',
+  patrolDescription: '执行过程中每隔若干步自动把会话快照发给审查模型检查方向；发现跑偏会在下一步注入纠偏，STOP 时要求执行模型停下向用户报告。每次巡逻整段会话计费一次审查模型。',
+  patrolToggle: '启用巡逻',
+  patrolEverySteps: '巡逻间隔（步数）',
+  patrolEveryStepsHint: '每 N 个模型请求做一次巡逻检查；两次巡逻之间另有至少 90 秒的节流。',
+  patrolImmuneTurns: '纠偏冷却（请求数）',
+  investigateToggle: '审查者调查工具',
+  investigateHint: '允许审查模型在裁决前用只读工具（工作区内搜索/读文件）亲自核实事实；重复建议与空话建议会被自动去重/丢弃。',
+  toolTitle: '咨询',
+  toolRunning: '进行中',
+  toolDone: '完成',
+  toolFailed: '失败',
+  toolConsulting: '正在向审查模型转发整段会话…',
+  toolExpand: '展开建议全文',
+  toolCollapse: '收起',
+  patrolCardTitle: '巡逻裁决',
+  patrolCheckTitle: '巡逻检查',
+  patrolVerdictOnTrack: '正常',
+  patrolVerdictCorrection: '纠偏',
+  patrolVerdictStop: '叫停',
+  patrolCardStepPrefix: '第 ',
+  patrolCardStepSuffix: ' 步',
+  patrolExpand: '展开裁决全文',
+  patrolCollapse: '收起',
+  patrolDowngradedTag: '冷却降级·未注入',
+} as const
+
+export type LocaleKey = keyof typeof zh
+
+export const en: Record<LocaleKey, string> = {
+  title: 'Advisor reviewer model',
+  description: 'The executor model may call the zero-parameter advisor() tool when stuck, before major decisions, or before declaring done. The whole conversation is forwarded to this reviewer each call — escalation is not free.',
+  armed: 'Current reviewer',
+  off: 'None selected — the advisor tool is hidden from the model (zero prompt cost)',
+  offCurrent: 'None selected',
+  choose: 'Pick one of the models DSH already has configured:',
+  loading: 'Loading model catalog…',
+  loadFailed: 'Failed to load the model catalog',
+  retry: 'Retry',
+  partial: 'Some providers failed to list models; the catalog may be incomplete.',
+  empty: 'No configurable models — configure a provider under Settings → Models first.',
+  effort: 'Reasoning effort',
+  effortDefault: '(model default)',
+  effortHint: 'Leave empty for the model default; this model declares no effort support — an unsupported configured effort falls back to the model default automatically (see logs).',
+  effortHintKnown: 'Only levels this model declares as supported are listed; empty means the model default.',
+  unavailable: '(configured route is not in the current catalog)',
+  save: 'Save',
+  saving: 'Saving…',
+  discard: 'Discard changes',
+  saved: 'Saved',
+  saveFailed: 'Save failed, please retry',
+  readonly: 'The settings document is read-only here.',
+  patrolTitle: 'Patrol mode (automatic drift detection)',
+  patrolDescription: 'Every few steps the conversation snapshot is sent to the reviewer to check direction; on drift a correction is injected into the next request, and STOP asks the executor to halt and report. Each patrol bills the full conversation to the reviewer once.',
+  patrolToggle: 'Enable patrol',
+  patrolEverySteps: 'Patrol interval (steps)',
+  patrolEveryStepsHint: 'One patrol check per N model requests; throttled to at most one patrol per 90 seconds.',
+  patrolImmuneTurns: 'Correction cooldown (requests)',
+  investigateToggle: 'Reviewer investigation tools',
+  investigateHint: 'Let the reviewer verify facts with read-only tools (workspace search / file read) before ruling; duplicate and content-free advice is auto-deduped/dropped.',
+  toolTitle: 'consultation',
+  toolRunning: 'running',
+  toolDone: 'done',
+  toolFailed: 'failed',
+  toolConsulting: 'forwarding the whole conversation to the reviewer…',
+  toolExpand: 'show guidance',
+  toolCollapse: 'collapse',
+  patrolCardTitle: 'patrol verdict',
+  patrolCheckTitle: 'patrol check',
+  patrolVerdictOnTrack: 'on track',
+  patrolVerdictCorrection: 'correction',
+  patrolVerdictStop: 'stop',
+  patrolCardStepPrefix: 'step ',
+  patrolCardStepSuffix: '',
+  patrolExpand: 'show verdict',
+  patrolCollapse: 'collapse',
+  patrolDowngradedTag: 'cooldown·not injected',
+}