dsh-code 1.0.1 → 1.0.3

package/src/internals.ts

@@ -8,7 +8,16 @@
 
 import { render } from 'ink'
 import type { ReactElement } from 'react'
-import { BRACKETED_PASTE_DISABLE, BRACKETED_PASTE_ENABLE, KEYBOARD_ENHANCE_DISABLE, KEYBOARD_ENHANCE_ENABLE } from './keyboard.ts'
+import {
+  BRACKETED_PASTE_DISABLE,
+  BRACKETED_PASTE_ENABLE,
+  KEYBOARD_ENHANCE_DISABLE,
+  KEYBOARD_ENHANCE_ENABLE,
+  TERMINAL_FOCUS_REPORT_DISABLE,
+  TERMINAL_FOCUS_REPORT_ENABLE,
+  isVsCodeTerminalEnv,
+  shouldEnableKeyboardEnhancement,
+} from './keyboard.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -29,11 +38,16 @@ export const internals: {
   stderr: { write(chunk: string): unknown }
 } = {
   mount: (element: ReactElement): TuiMount => {
-    // Codex keyboard_modes parity: push the kitty keyboard protocol so
-    // modified controls remain distinguishable, and enable bracketed paste so
-    // pasted newlines insert instead of submitting. Both are inert in
-    // terminals without support.
-    process.stdout.write(KEYBOARD_ENHANCE_ENABLE + BRACKETED_PASTE_ENABLE)
+    // VS Code's integrated terminal can route Tab to the workbench when Kitty
+    // enhancement is enabled. Keep bracketed paste everywhere, but only push
+    // the keyboard protocol on terminals that can safely own those key events.
+    const keyboardEnhanced = shouldEnableKeyboardEnhancement()
+    const focusReporting = isVsCodeTerminalEnv()
+    process.stdout.write(
+      (keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : '')
+      + BRACKETED_PASTE_ENABLE
+      + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''),
+    )
     // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
     // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
     // normalized control byte first, unmount only its renderer, and leave the
@@ -45,9 +59,12 @@ export const internals: {
       },
       unmount(): void {
         instance.unmount()
-        // Pop the stack so the parent shell does not inherit enhanced key
-        // reporting (Codex resets even harder on forced exit).
-        process.stdout.write(KEYBOARD_ENHANCE_DISABLE + BRACKETED_PASTE_DISABLE)
+        // Pop only a stack this mount pushed, then disable bracketed paste.
+        process.stdout.write(
+          (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
+          + BRACKETED_PASTE_DISABLE
+          + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
+        )
       },
     }
   },

package/src/keyboard.ts

@@ -20,13 +20,56 @@
 export const KEYBOARD_ENHANCE_ENABLE = '\x1b[>4;0m\x1b[>5u'
 
 /** Pop the enhancement stack and reset modifyOtherKeys (exit path). */
-export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
-
-/** Enable bracketed paste reporting. */
-export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
+
+/** Explicit environment overrides for terminal keyboard enhancement. */
+export const DSH_DISABLE_KEYBOARD_ENHANCEMENT = 'DSH_DISABLE_KEYBOARD_ENHANCEMENT'
+export const DSH_ENABLE_KEYBOARD_ENHANCEMENT = 'DSH_ENABLE_KEYBOARD_ENHANCEMENT'
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined
+  const normalized = value.trim().toLowerCase()
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') return true
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') return false
+  return undefined
+}
+
+/** True when the process is running inside the VS Code integrated terminal. */
+export function isVsCodeTerminalEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.TERM_PROGRAM?.trim().toLowerCase() === 'vscode' || env.VSCODE_INJECTION === '1'
+}
+
+/** Whether to push Kitty keyboard enhancement for the current terminal. */
+export function shouldEnableKeyboardEnhancement(env: NodeJS.ProcessEnv = process.env): boolean {
+  const explicitDisable = parseBooleanEnv(env[DSH_DISABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitDisable === true) return false
+  const explicitEnable = parseBooleanEnv(env[DSH_ENABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitEnable !== undefined) return explicitEnable
+  return !isVsCodeTerminalEnv(env)
+}
 
-/** Disable bracketed paste reporting. */
-export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+/** Enable bracketed paste reporting. */
+export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+
+/** Disable bracketed paste reporting. */
+export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+
+/** Enable terminal focus-in/focus-out reporting (xterm focus protocol). */
+export const TERMINAL_FOCUS_REPORT_ENABLE = '\x1b[?1004h'
+
+/** Disable terminal focus-in/focus-out reporting. */
+export const TERMINAL_FOCUS_REPORT_DISABLE = '\x1b[?1004l'
+
+/**
+ * Remove xterm focus reports from one input chunk and update the caller's
+ * focus state. Focus reports are terminal protocol, not composer text.
+ */
+export function stripTerminalFocusEvents(chunk: string, onFocus: (focused: boolean) => void): string {
+  return chunk.replace(/\x1b\[(I|O)/gu, (_whole, event: string) => {
+    onFocus(event === 'I')
+    return ''
+  })
+}
 
 /** Bracketed paste markers as Ink delivers them (it strips the leading ESC). */
 export const PASTE_START_MARKER = '[200~'
@@ -123,4 +166,85 @@ export function normalizeKeyboardChunk(chunk: string): string {
     })
     return legacy ?? whole
   })
-}
+}
+
+/** Editor actions Ink cannot distinguish reliably when terminal bytes batch. */
+export type RawEditorToken =
+  | { readonly kind: 'text'; readonly text: string }
+  | { readonly kind: 'home' | 'end' | 'delete-backward' | 'delete-word-backward' | 'delete-forward' | 'delete-word-forward' }
+
+const HOME_SEQUENCES = ['\x1b[H', '\x1b[1~', '\x1b[7~', '\x1bOH'] as const
+const END_SEQUENCES = ['\x1b[F', '\x1b[4~', '\x1b[8~', '\x1bOF'] as const
+
+/** Parse one CSI functional-key sequence at `offset`. */
+function functionalToken(chunk: string, offset: number): { token: RawEditorToken; length: number } | undefined {
+  const tail = chunk.slice(offset)
+  for (const sequence of HOME_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'home' }, length: sequence.length }
+  }
+  for (const sequence of END_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'end' }, length: sequence.length }
+  }
+  const modifiedHome = /^\x1b\[1;(\d+)H/u.exec(tail)
+  if (modifiedHome !== null) return { token: { kind: 'home' }, length: modifiedHome[0].length }
+  const modifiedEnd = /^\x1b\[1;(\d+)F/u.exec(tail)
+  if (modifiedEnd !== null) return { token: { kind: 'end' }, length: modifiedEnd[0].length }
+  const modifiedDelete = /^\x1b\[3(?:;(\d+))?~/u.exec(tail)
+  if (modifiedDelete !== null) {
+    const modifiers = Number.parseInt(modifiedDelete[1] ?? '1', 10) - 1
+    const byWord = (modifiers & 2) !== 0 || (modifiers & 4) !== 0
+    return {
+      token: { kind: byWord ? 'delete-word-forward' : 'delete-forward' },
+      length: modifiedDelete[0].length,
+    }
+  }
+  return undefined
+}
+
+/**
+ * Tokenize a stdin chunk containing at least one editor-only key. Ink calls
+ * `useInput` once for a pasted/batched chunk, so preserving each action here
+ * prevents repeated Backspace/Home/End/Delete presses from collapsing into
+ * one blurred key event. Unknown escape sequences return undefined and stay
+ * under Ink's ownership.
+ */
+export function tokenizeRawEditorChunk(chunk: string): readonly RawEditorToken[] | undefined {
+  const tokens: RawEditorToken[] = []
+  let text = ''
+  let special = false
+  const flushText = (): void => {
+    if (text === '') return
+    tokens.push({ kind: 'text', text })
+    text = ''
+  }
+  for (let offset = 0; offset < chunk.length;) {
+    if (chunk.startsWith('\x1b\x7f', offset) || chunk.startsWith('\x1b\b', offset)) {
+      flushText()
+      tokens.push({ kind: 'delete-word-backward' })
+      special = true
+      offset += 2
+      continue
+    }
+    const functional = functionalToken(chunk, offset)
+    if (functional !== undefined) {
+      flushText()
+      tokens.push(functional.token)
+      special = true
+      offset += functional.length
+      continue
+    }
+    const char = chunk[offset]!
+    if (char === '\x7f' || char === '\b') {
+      flushText()
+      tokens.push({ kind: 'delete-backward' })
+      special = true
+      offset += 1
+      continue
+    }
+    if (char === '\x1b') return undefined
+    text += char
+    offset += 1
+  }
+  flushText()
+  return special ? tokens : undefined
+}

package/src/mentions.ts

@@ -75,6 +75,11 @@ interface FileReferenceServiceLike {
 /** Menu cap on file rows; the service owns ranking and default rows. */
 const MAX_FILE_ROWS = 20
 
+/** Whether a mention token is already navigating a filesystem path. */
+export function isPathLikeMentionQuery(query: string): boolean {
+  return /[\\/]/u.test(query)
+}
+
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
   /** Ranked menu candidates for the typed `@` query. */
@@ -136,7 +141,7 @@ export function createMentions(ctx: Context, agent: Agent | undefined, cwd: stri
           : agent === undefined
             ? preSessionFiles(needle, signal).catch(() => [] as readonly ServiceFileCandidate[])
             : Promise.resolve([] as readonly ServiceFileCandidate[]),
-        sessionCapable && needle !== '' && agent !== undefined
+        sessionCapable && needle !== '' && !isPathLikeMentionQuery(needle) && agent !== undefined
           ? resolver!.listCandidates(agent, needle, 10, signal).catch(() => [] as readonly SessionReferenceCandidate[])
           : Promise.resolve([] as readonly SessionReferenceCandidate[]),
       ])

package/src/model-capabilities.ts

@@ -0,0 +1,318 @@
+/**
+ * Same-id reasoning-capability inheritance for hand-declared pi-ai routes:
+ * the model catalog inherits capabilities by route key, not by model id, so a
+ * relay route listing `gpt-5.5` reads nothing from the installed `openai`
+ * catalog entry and materializes as `reasoning: false` until its settings
+ * entry declares `reasoningEfforts`. This adapter closes that gap without
+ * touching upstream: whenever a pi-ai profile's model entry carries no
+ * declaration and its live row advertises no efforts, but the same model id
+ * is declared (in a sibling settings entry) or advertised (on another route)
+ * elsewhere, the declaration is materialized into settings — verbatim from a
+ * sibling declaration when one exists, otherwise as an identity level map
+ * (`off` maps to null, every other level to its own name), which is the
+ * correct wire spelling for OpenAI-compatible relays. Writes ride the same
+ * `settings.mutate` path as the provider panel, so the upstream
+ * `assertServiceable` gate still rejects anything invalid atomically.
+ *
+ * @module @deepseek-ai/dsh-tui/model-capabilities
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import { loadModelDirectory, type ModelRow } from './models.ts'
+
+/** The settings namespace the llm-pi-ai plugin owns (identity via `settingsNamespace`). */
+const PI_AI_SETTINGS_NS = 'llm-pi-ai'
+
+/** The effort level that means "send no reasoning parameter"; its wire value is always null. */
+const OFF_LEVEL = 'off'
+
+/* ------------------------------------------------------------------ *
+ * Structural service faces (same discipline as provider-settings: the
+ * settings package is never imported, only described structurally).
+ * ------------------------------------------------------------------ */
+
+/** One configurable-provider directory entry (subset of the `llm` service face). */
+interface ConfigurableEntryFace {
+  readonly provider: string
+  readonly settingsNs: string
+  readonly settingsPath: readonly string[]
+}
+
+/** One redacted settings descriptor (subset of `SettingsDescriptor`). */
+interface DescriptorFace {
+  readonly ns: string
+  readonly value: unknown
+  readonly revision: number
+}
+
+/** One path-addressed edit to a stored section (subset of `SettingsPathOp`). */
+interface PathOpFace {
+  readonly op: 'set' | 'unset'
+  readonly path: readonly string[]
+  readonly value?: unknown
+}
+
+/** The subset of the `settings` service this module reads and writes. */
+interface SettingsFace {
+  describe(options?: { readonly redactSecrets?: boolean }): readonly DescriptorFace[]
+  mutate(ns: string, ops: readonly PathOpFace[], expectedRevision?: number): Promise<void>
+}
+
+/** A notice sink structurally compatible with the app bridge's `notify`. */
+export type CapabilityNotice = (text: string, tone?: 'info' | 'warning' | 'error') => void
+
+/** Single-line a misbehaving error for the notice channel. */
+function singleLine(message: string): string {
+  const spaced = [...message].map(ch => { const code = ch.charCodeAt(0); return code < 32 || code === 127 ? ' ' : ch }).join('')
+  return spaced.split(' ').filter(part => part !== '').join(' ')
+}
+
+/** Human text for a rejection value. */
+function messageOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/** Read the value at a path through plain objects; undefined when any segment misses. */
+function getPath(value: unknown, path: readonly string[]): unknown {
+  let current = value
+  for (const segment of path) {
+    if (typeof current !== 'object' || current === null) return undefined
+    current = (current as Record<string, unknown>)[segment]
+  }
+  return current
+}
+
+/** Whether a raw settings value is a usable `reasoningEfforts` dict (non-empty, non-false). */
+function isDeclaredEfforts(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0
+}
+
+/**
+ * The identity level map for an advertised effort list: `off` sends no
+ * parameter, every other level keeps its own name — the wire spelling
+ * OpenAI-compatible relays accept as-is.
+ */
+function identityEfforts(levels: readonly string[]): Record<string, string | null> {
+  const dict: Record<string, string | null> = {}
+  for (const level of levels) dict[level] = level === OFF_LEVEL ? null : level
+  return dict
+}
+
+/* ------------------------------------------------------------------ *
+ * Pure planning.
+ * ------------------------------------------------------------------ */
+
+/** One pi-ai provider profile as stored in settings, addressed for mutation. */
+export interface CapabilityProfileSource {
+  /** Settings namespace owning the profile (`llm-pi-ai`). */
+  readonly settingsNs: string
+  /** Path from the section root to this provider's profile. */
+  readonly settingsPath: readonly string[]
+  /** Revision of the owning section at read time. */
+  readonly revision: number
+  /** Raw model entries, exactly as stored (declaration fields included). */
+  readonly models: readonly Record<string, unknown>[]
+}
+
+/** One planned per-provider models rewrite. */
+export interface CapabilitySyncPlan {
+  /** Provider route the plan targets. */
+  readonly provider: string
+  /** Settings namespace owning the profile. */
+  readonly settingsNs: string
+  /** Path from the section root to the provider profile. */
+  readonly settingsPath: readonly string[]
+  /** Raw model entries, exactly as stored (declaration fields included). */
+  readonly models: readonly Record<string, unknown>[]
+  /** Fingerprint of the source models array this plan was derived from. */
+  readonly sourceFingerprint: string
+  /** Document revision of the owning section when the plan was derived. */
+  readonly sourceRevision: number
+  /** Model ids that gained a declaration, notice-facing. */
+  readonly inherited: readonly string[]
+  /** `provider/model` labels the declarations came from, notice-facing. */
+  readonly sources: readonly string[]
+}
+
+/**
+ * Plan the reasoning declarations to materialize. A model entry inherits
+ * when it declares nothing (`reasoningEfforts` absent — a dict or `false` is
+ * an explicit choice and is never touched) and its live row advertises no
+ * efforts; the donor is the first sibling settings declaration for the same
+ * id, copied verbatim so dialect wire spellings survive, otherwise the first
+ * other-route row advertising efforts for that id, mapped by identity.
+ * Entries never lose fields and keep their key order; a provider appears in
+ * the result only when at least one entry changes.
+ * @param input - the live model rows and the raw pi-ai profiles from settings.
+ * @returns one plan per provider with at least one inheritance.
+ */
+export function planCapabilitySync(input: {
+  readonly rows: readonly ModelRow[]
+  readonly profiles: ReadonlyMap<string, CapabilityProfileSource>
+}): readonly CapabilitySyncPlan[] {
+  // Sibling declarations, first profile order wins: { id -> { dict, provider } }.
+  const declared = new Map<string, { dict: Record<string, unknown>; provider: string }>()
+  for (const [provider, profile] of input.profiles) {
+    for (const entry of profile.models) {
+      const efforts = entry.reasoningEfforts
+      if (!isDeclaredEfforts(efforts)) continue
+      if (!declared.has(String(entry.id))) declared.set(String(entry.id), { dict: efforts, provider })
+    }
+  }
+  // Advertised donors, first row order wins: { id -> { levels, provider } }.
+  // A row whose only level is `off` advertises nothing usable and is skipped.
+  const advertised = new Map<string, { levels: readonly string[]; provider: string }>()
+  for (const row of input.rows) {
+    const levels = row.reasoning?.efforts.map(effort => effort.id) ?? []
+    if (levels.filter(level => level !== OFF_LEVEL).length === 0) continue
+    if (!advertised.has(row.model)) advertised.set(row.model, { levels, provider: row.provider })
+  }
+  const plans: CapabilitySyncPlan[] = []
+  for (const [provider, profile] of input.profiles) {
+    const inherited: string[] = []
+    const sources: string[] = []
+    const models = profile.models.map((entry): Record<string, unknown> => {
+      if (entry.reasoningEfforts !== undefined) return entry
+      const id = String(entry.id)
+      const sibling = declared.get(id)
+      if (sibling !== undefined && sibling.provider !== provider) {
+        inherited.push(id)
+        if (!sources.includes(`${sibling.provider}/${id}`)) sources.push(`${sibling.provider}/${id}`)
+        return { ...entry, reasoningEfforts: sibling.dict }
+      }
+      const donor = advertised.get(id)
+      if (donor !== undefined && donor.provider !== provider) {
+        inherited.push(id)
+        if (!sources.includes(`${donor.provider}/${id}`)) sources.push(`${donor.provider}/${id}`)
+        return { ...entry, reasoningEfforts: identityEfforts(donor.levels) }
+      }
+      return entry
+    })
+    if (inherited.length > 0) {
+      plans.push({
+        provider,
+        settingsNs: profile.settingsNs,
+        settingsPath: profile.settingsPath,
+        models,
+        sourceFingerprint: JSON.stringify(profile.models),
+        sourceRevision: profile.revision,
+        inherited,
+        sources,
+      })
+    }
+  }
+  return plans
+}
+
+/* ------------------------------------------------------------------ *
+ * Application.
+ * ------------------------------------------------------------------ */
+
+/** Provider -> the source snapshot and document revision its last write landed against. */
+const lastApplied = new Map<string, { fingerprint: string; revision: number }>()
+
+/** Fresh revision of one namespace, or undefined when it does not resolve. */
+function revisionOf(settings: SettingsFace, ns: string): number | undefined {
+  try {
+    for (const descriptor of settings.describe({ redactSecrets: true })) {
+      if (descriptor.ns === ns) return descriptor.revision
+    }
+  } catch {
+    return undefined
+  }
+  return undefined
+}
+
+/**
+ * Materialize same-id reasoning declarations once per provider. Reads the
+ * configurable directory, the redacted settings document, and the live model
+ * rows; plans; then writes each provider's merged models array through
+ * `settings.mutate` under a fresh revision (writes bump the section
+ * revision, so per-plan revisions are re-read). Every failure converges to a
+ * single-line notice — the caller's promise never rejects and the session
+ * keeps running on the previous configuration.
+ * @param ctx - context carrying the `llm` and `settings` services (optional).
+ * @param notify - the app bridge's notice sink, when one is live.
+ */
+export async function syncModelCapabilities(ctx: Context, notify?: CapabilityNotice): Promise<void> {
+  try {
+    const llm = ctx.get('llm') as { listConfigurableProviders?: () => readonly ConfigurableEntryFace[] } | undefined
+    if (llm?.listConfigurableProviders === undefined) return
+    const settings = ctx.get('settings') as SettingsFace | undefined
+    if (settings === undefined) return
+    let entries: readonly ConfigurableEntryFace[]
+    try {
+      entries = llm.listConfigurableProviders()
+    } catch {
+      return
+    }
+    const routed = entries.filter(entry => entry.settingsNs === PI_AI_SETTINGS_NS)
+    if (routed.length === 0) return
+    let descriptors: readonly DescriptorFace[]
+    try {
+      descriptors = settings.describe({ redactSecrets: true })
+    } catch {
+      return
+    }
+    const namespaces = new Map(descriptors.map(descriptor => [descriptor.ns, descriptor] as const))
+    const profiles = new Map<string, CapabilityProfileSource>()
+    for (const entry of routed) {
+      const namespace = namespaces.get(entry.settingsNs)
+      if (namespace === undefined) continue
+      const profile = entry.settingsPath.length === 0
+        ? namespace.value
+        : getPath(namespace.value, entry.settingsPath)
+      const models = Array.isArray((profile as { models?: unknown } | null)?.models)
+        ? (profile as { models: unknown }).models as readonly Record<string, unknown>[]
+        : undefined
+      // An absent models list is a dormant or unconfigured route: nothing to
+      // inherit into (and the empty allow-list there is deliberate upstream).
+      if (models === undefined) continue
+      profiles.set(entry.provider, {
+        settingsNs: entry.settingsNs,
+        settingsPath: entry.settingsPath,
+        revision: namespace.revision,
+        models,
+      })
+    }
+    if (profiles.size === 0) return
+    const directory = await loadModelDirectory(ctx)
+    for (const plan of planCapabilitySync({ rows: directory.rows, profiles })) {
+      // Skip only a provable echo of our own write: the same source
+      // snapshot at the same document revision we already wrote against
+      // (our write re-triggers the document event before the re-read
+      // catches up). An external edit that removes a materialized
+      // declaration bumps the revision, so identical source content
+      // re-plans and re-writes instead of being skipped forever.
+      const applied = lastApplied.get(plan.provider)
+      if (applied !== undefined && applied.fingerprint === plan.sourceFingerprint && applied.revision === plan.sourceRevision) continue
+      // Writes bump the section revision; re-read per plan so the second
+      // provider's optimistic revision is not already stale.
+      const revision = revisionOf(settings, plan.settingsNs)
+      if (revision === undefined) continue
+      try {
+        await settings.mutate(
+          plan.settingsNs,
+          [{ op: 'set', path: [...plan.settingsPath, 'models'], value: plan.models }],
+          revision,
+        )
+        lastApplied.set(plan.provider, { fingerprint: plan.sourceFingerprint, revision: plan.sourceRevision })
+        const shown = plan.sources.slice(0, 3).join(', ')
+        const more = plan.sources.length > 3 ? `, +${plan.sources.length - 3}` : ''
+        notify?.(
+          `inherited reasoning levels for ${plan.inherited.length} model${plan.inherited.length === 1 ? '' : 's'} on ${plan.provider} (from ${shown}${more})`,
+          'info',
+        )
+      } catch (error) {
+        notify?.(`capability inheritance failed on ${plan.provider}: ${singleLine(messageOf(error))}`, 'warning')
+      }
+    }
+  } catch {
+    // A background sync must never surface as an unhandled rejection.
+  }
+}
+
+/** Test seam: forget the applied-write fingerprints. */
+export function resetCapabilitySyncState(): void {
+  lastApplied.clear()
+}

package/src/provider-settings.ts

@@ -138,11 +138,16 @@ function configurationOf(profile: unknown): ProviderConfiguration {
     if (typeof value !== 'object' || value === null) return []
     const entry = value as Record<string, unknown>
     if (typeof entry.id !== 'string' || entry.id.trim() === '') return []
+    // Fields the editor does not understand ride along untouched: dropping
+    // them here would let the next save strip hand-written reasoningEfforts
+    // or compat declarations out of the stored profile.
+    const { id: _id, name: _name, contextWindow: _contextWindow, maxTokens: _maxTokens, ...extras } = entry
     return [{
       id: entry.id,
       ...(typeof entry.name === 'string' && entry.name.trim() !== '' ? { name: entry.name } : {}),
       ...(typeof entry.contextWindow === 'number' && Number.isFinite(entry.contextWindow) ? { contextWindow: entry.contextWindow } : {}),
       ...(typeof entry.maxTokens === 'number' && Number.isFinite(entry.maxTokens) ? { maxTokens: entry.maxTokens } : {}),
+      ...Object.keys(extras).length > 0 ? { extras } : {},
     }]
   })
   return {
@@ -194,6 +199,13 @@ export interface ProviderModelSettings {
   readonly name?: string
   readonly contextWindow?: number
   readonly maxTokens?: number
+  /**
+   * Remaining entry fields the editor does not model (`reasoningEfforts`,
+   * `compat`, `input`, …), carried verbatim so a save preserves them.
+   * Populated by {@link loadProviderSettings}; never contains the four
+   * modelled keys.
+   */
+  readonly extras?: Readonly<Record<string, unknown>>
 }
 
 /** The small, portable subset of a provider profile the terminal edits. */
@@ -514,6 +526,10 @@ export async function saveProviderConfiguration(
     }
     return {
       id,
+      // Editor-invisible fields ride along after the id; the modelled keys
+      // spread last so a panel edit (or clear) always wins over a carried
+      // value. extras never contains those keys — see configurationOf.
+      ...model.extras,
       ...(model.name === undefined || model.name.trim() === '' ? {} : { name: model.name.trim() }),
       ...(model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow }),
       ...(model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens }),