dsh-ntr 0.1.2 → 0.1.4

package/src/bridge.ts

@@ -37,7 +37,9 @@ import {
   childEnv,
   isAcpToolContinuation,
   isUnderPath,
+  mergeCatalogShape,
   parseCatalogOptions,
+  usableConfigOptions,
   permissionToolKind,
   quoteCommandToken,
   randomUUID,
@@ -73,7 +75,7 @@ const FS_MAX_WRITE_BYTES = 2 * 1024 * 1024
 interface DisplayedChatDefaults {
   modelId?: string
   effort?: string
-  extraConfigs?: Record<string, string>
+  extraConfigs?: Record<string, string | boolean>
 }
 
 interface LiveSession {
@@ -351,8 +353,14 @@ export class AgentBridge {
     private readonly transcriptMax: number,
     /** Called when the connection dies so the manager can settle outstanding prompts. */
     private readonly onConnectionLost: (bridge: AgentBridge, reason: string) => void,
-    /** Observes `configOptions` from any real session so the manager's model catalog stays warm. */
-    private readonly onCatalog?: (agentId: string, configOptions: unknown) => void,
+    /**
+     * Observes `configOptions` from any real session so the manager's model
+     * catalog stays warm. `shapeOnly` marks a per-session answer (a
+     * `session/set_config_option` response): only the option SHAPE belongs in
+     * the agent-level catalog, never its `currentValue` — see
+     * {@link BridgeManager.absorbCatalogShape}.
+     */
+    private readonly onCatalog?: (agentId: string, configOptions: unknown, shapeOnly?: boolean) => void,
     /** Observes `availableCommands` from any real session so the agent's slash menu survives its sessions. */
     private readonly onCommands?: (agentId: string, commands: NonNullable<SessionView['availableCommands']>) => void,
     tuning?: BridgeTuning,
@@ -707,7 +715,14 @@ export class AgentBridge {
         protocolVersion: PROTOCOL_VERSION,
         // The fs handlers are implemented below behind the same workspace
         // sandbox that gates session cwds; terminal is not implemented.
-        clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false },
+        // `session.configOptions.boolean` advertises the toggle form of
+        // `configOptions`; agents that gate `type: "boolean"` entries on it
+        // would otherwise never publish them.
+        clientCapabilities: {
+          fs: { readTextFile: true, writeTextFile: true },
+          terminal: false,
+          session: { configOptions: { boolean: {} } },
+        },
         clientInfo: { name: 'dsh-ntr', title: 'DSH NTR', version: '0.1.0' },
       }),
       'initialize',
@@ -765,7 +780,8 @@ export class AgentBridge {
       conn.agent.request(methods.agent.session.new, { cwd: resolved, mcpServers: [] }),
       'session/new',
     )
-    if (this.onCatalog !== undefined && result.configOptions !== undefined && result.configOptions !== null) {
+    // An empty `configOptions` answer is a non-answer — see `usableConfigOptions`.
+    if (this.onCatalog !== undefined && usableConfigOptions(result.configOptions)) {
       this.onCatalog(this.def.id, result.configOptions)
     }
     const session: LiveSession = {
@@ -790,7 +806,7 @@ export class AgentBridge {
           },
         }
         : {}),
-      ...(result.configOptions !== undefined && result.configOptions !== null ? { configOptions: result.configOptions } : {}),
+      ...(usableConfigOptions(result.configOptions) ? { configOptions: result.configOptions } : {}),
     }
     this.sessions.set(session.sessionId, session)
     this.acpIndex.set(session.acpSessionId, session)
@@ -970,7 +986,7 @@ export class AgentBridge {
         conn.agent.request(methods.agent.session.load, { sessionId: session.acpSessionId, cwd: resolved, mcpServers: [] }),
         'session/load',
       )
-      if (this.onCatalog !== undefined && result.configOptions !== undefined && result.configOptions !== null) {
+      if (this.onCatalog !== undefined && usableConfigOptions(result.configOptions)) {
         this.onCatalog(this.def.id, result.configOptions)
       }
       session.modes = result.modes !== undefined && result.modes !== null
@@ -983,7 +999,7 @@ export class AgentBridge {
           })),
         }
         : session.modes
-      if (Array.isArray(result.configOptions)) session.configOptions = result.configOptions
+      if (usableConfigOptions(result.configOptions)) session.configOptions = result.configOptions
       this.sessions.set(session.sessionId, session)
       this.released.delete(session.sessionId)
       // Same flip as `createSession`: a registered session makes this a chat
@@ -1077,14 +1093,26 @@ export class AgentBridge {
   async setConfigOption(session: LiveSession, configId: string, value: string | boolean): Promise<void> {
     const conn = this.conn
     if (conn === undefined) throw new AcpError('agent_unreachable', 'acp: connection is not open')
-    const result = await this.runCommand(() => conn.agent.request(methods.agent.session.setConfigOption, { sessionId: session.acpSessionId, configId, value })) as { configOptions?: unknown }
+    // A toggle must say so on the wire: the request union discriminates on
+    // `type`, and a bare boolean `value` is not a select value id.
+    const params = typeof value === 'boolean'
+      ? { sessionId: session.acpSessionId, configId, value, type: 'boolean' as const }
+      : { sessionId: session.acpSessionId, configId, value }
+    const result = await this.runCommand(() => conn.agent.request(methods.agent.session.setConfigOption, params)) as { configOptions?: unknown }
     // The response carries the full authoritative option set; some agents
     // (pi-acp observed) never re-notify after a client-driven set. It feeds the
-    // SESSION snapshot only — never the agent-level catalog: `currentValue` in
-    // a per-session answer describes this session's pick, and promoting it to
-    // the catalog would turn the seat's own choice into `reasoning.defaultEffort`
-    // for every other conversation (and back onto itself next turn).
-    if (Array.isArray(result.configOptions)) session.configOptions = result.configOptions as unknown[]
+    // SESSION snapshot first — `currentValue` in a per-session answer describes
+    // this session's pick, and promoting it to the catalog would turn the
+    // seat's own choice into `reasoning.defaultEffort` for every other
+    // conversation (and back onto itself next turn). The option SHAPE still
+    // reaches the agent-level catalog (`shapeOnly`): this response is often the
+    // only place an agent publishes how its option set changes with the model
+    // (opencode offers `thought_level` just for models with variants), and the
+    // composer's thought chip is driven by the catalog.
+    if (usableConfigOptions(result.configOptions)) {
+      session.configOptions = result.configOptions
+      this.onCatalog?.(this.def.id, result.configOptions, true)
+    }
     this.publishMeta(session)
   }
 
@@ -1372,7 +1400,9 @@ export class AgentBridge {
         session.modes = { ...session.modes, currentModeId: update.currentModeId }
         break
       case 'config_option_update':
-        session.configOptions = update.configOptions ?? []
+        // Empty answers never overwrite the last known set — see `usableConfigOptions`.
+        if (!usableConfigOptions(update.configOptions)) break
+        session.configOptions = update.configOptions
         this.onCatalog?.(this.def.id, session.configOptions)
         break
       case 'available_commands_update':
@@ -2720,7 +2750,7 @@ export class BridgeManager {
   private makeBridge(
     def: AcpAgentDef,
     onConnectionLost: (bridge: AgentBridge, reason: string) => void,
-    onCatalog?: (agentId: string, configOptions: unknown) => void,
+    onCatalog?: (agentId: string, configOptions: unknown, shapeOnly?: boolean) => void,
     onCommands?: (agentId: string, commands: NonNullable<SessionView['availableCommands']>) => void,
   ): AgentBridge {
     return new AgentBridge(def, this.hub, this.transcriptMax, onConnectionLost, onCatalog, onCommands, this.tuning, () => this.approvalRequester, () => this.sessionWorkspaceResolver)
@@ -3173,7 +3203,7 @@ export class BridgeManager {
    * A live session is updated immediately; a failure there is warned about and
    * the pick still stands, exactly like the model/effort alignment path.
    */
-  async setChatSessionConfig(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void> {
+  async setChatSessionConfig(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void> {
     // `agentId` is the route the composer showed — including the plugin
     // default, which `chatAgentFor` cannot report before the first session.
     const bound = agentId ?? this.chatAgentFor(dshSessionId)
@@ -3197,8 +3227,18 @@ export class BridgeManager {
     if (option === undefined) {
       throw new AcpError('unknown_config', `acp: agent "${bound}" publishes no extra config option "${configId}"`)
     }
-    if (!option.choices.some(choice => choice.value === value)) {
-      throw new AcpError('bad_config', `acp: "${value}" is not a value of config option "${configId}"`)
+    if (option.kind === 'boolean') {
+      // The browser sends 'true' / 'false' from a checkbox row; the wire and
+      // the persisted pick both use the real boolean.
+      const toggle = typeof value === 'boolean'
+        ? value
+        : value === 'true' ? true : value === 'false' ? false : undefined
+      if (toggle === undefined) {
+        throw new AcpError('bad_config', `acp: "${String(value)}" is not a boolean value of config option "${configId}"`)
+      }
+      value = toggle
+    } else if (typeof value !== 'string' || !option.choices.some(choice => choice.value === value)) {
+      throw new AcpError('bad_config', `acp: "${String(value)}" is not a value of config option "${configId}"`)
     }
     const current = this.chatAgentIntent.get(dshSessionId)
     const extraConfigs = current?.agentId === bound ? { ...current.extraConfigs } : {}
@@ -3290,12 +3330,17 @@ export class BridgeManager {
           })
           continue
         }
-        if (!option.choices.some(entry => entry.value === value)) {
+        // A toggle's truth is its boolean itself; a select's is membership in
+        // the choices the agent still offers.
+        const usable = option.kind === 'boolean'
+          ? typeof value === 'boolean'
+          : typeof value === 'string' && option.choices.some(entry => entry.value === value)
+        if (!usable) {
           this.hub.broadcast({
             type: 'agent/notice',
             agentId: session.agentId,
             level: 'error',
-            text: `acp: agent "${session.agentId}" no longer offers "${value}" for config "${configId}"; keeping its own`,
+            text: `acp: agent "${session.agentId}" no longer offers "${String(value)}" for config "${configId}"; keeping its own`,
           })
           continue
         }
@@ -3513,7 +3558,7 @@ export class BridgeManager {
       if (typeof agentId !== 'string' || agentId === '') continue
       const configs = extraConfigs !== null && typeof extraConfigs === 'object' && !Array.isArray(extraConfigs)
         ? Object.fromEntries(Object.entries(extraConfigs as Record<string, unknown>)
-          .filter(([, value]) => typeof value === 'string' && value !== '')) as Record<string, string>
+          .filter(([, value]) => typeof value === 'boolean' || (typeof value === 'string' && value !== ''))) as Record<string, string | boolean>
         : {}
       this.chatAgentIntent.set(dshSessionId, {
         agentId,
@@ -3674,6 +3719,8 @@ export class BridgeManager {
    * current `parseCatalogOptions` has now seen this agent's real answer.
    */
   private absorbCatalog(agentId: string, configOptions: unknown): { catalog: AcpAgentCatalog; updatedAt: number } {
+    // Empty / absurd answers never overwrite known state — see `usableConfigOptions`.
+    if (!usableConfigOptions(configOptions)) return this.catalogs.get(agentId) ?? { catalog: {}, updatedAt: 0 }
     const catalog = parseCatalogOptions(configOptions)
     this.catalogStale.delete(agentId)
     const existing = this.catalogs.get(agentId)
@@ -3700,6 +3747,29 @@ export class BridgeManager {
     return entry
   }
 
+  /**
+   * Fold a per-session option answer's SHAPE into the agent's catalog.
+   *
+   * The counterpart of {@link absorbCatalog} for `session/set_config_option`
+   * responses: which options exist and which choices they offer is agent
+   * knowledge the seat must show (the composer's thought chip only renders
+   * when the catalog has `thought_level`, and some agents publish it only in
+   * the answer to a model change), while a per-session `currentValue` stays
+   * out of it. No auto-exposure and no staleness discharge either — this is
+   * one session's answer, not the agent-level observation those marks track.
+   */
+  private absorbCatalogShape(agentId: string, configOptions: unknown): void {
+    if (!usableConfigOptions(configOptions)) return
+    const observed = parseCatalogOptions(configOptions)
+    const existing = this.catalogs.get(agentId)
+    const catalog = mergeCatalogShape(existing?.catalog, observed)
+    if (existing !== undefined && JSON.stringify(existing.catalog) === JSON.stringify(catalog)) return
+    const entry = { catalog, updatedAt: Date.now() }
+    this.catalogs.set(agentId, entry)
+    this.persistCatalogs()
+    this.hub.broadcast({ type: 'catalog/updated', agentId, updatedAt: entry.updatedAt })
+  }
+
   /**
    * Remember the slash commands an agent declared in a real session.
    *
@@ -3732,11 +3802,12 @@ export class BridgeManager {
    * selection would resurrect a model the user deliberately unchecked every
    * time the agent repeats its catalog. The first observation has no baseline
    * (`before === undefined`), so it adds nothing; the user can still add the
-   * whole list with one click in the settings card.
+   * whole list with one click in the settings card. Discovery is ON unless the
+   * agent definition explicitly opts out with `autoDiscoverModels: false`.
    */
   private autoExposeNewModels(agentId: string, next: AcpAgentCatalog, before: AcpAgentCatalog | undefined): boolean {
     const def = this.defsMap.get(agentId)
-    if (def?.autoDiscoverModels !== true || before === undefined) return false
+    if (def === undefined || def.autoDiscoverModels === false || before === undefined) return false
     const known = new Set((before.model?.choices ?? []).map(choice => choice.value))
     const exposed = new Set(def.exposedModels ?? [])
     const added = (next.model?.choices ?? [])
@@ -3756,7 +3827,7 @@ export class BridgeManager {
       type: 'agent/exposure',
       agentId,
       exposedModels: [...(def.exposedModels ?? [])],
-      autoDiscoverModels: def.autoDiscoverModels === true,
+      autoDiscoverModels: def.autoDiscoverModels !== false,
     })
   }
 
@@ -3932,6 +4003,7 @@ export class BridgeManager {
         extras: extraOptions.map(option => ({
           configId: option.configId,
           name: option.name,
+          ...(option.kind === 'boolean' ? { kind: 'boolean' as const } : {}),
           ...(option.currentValue === null ? {} : { currentValue: option.currentValue }),
           choices: option.choices.map(choice => ({
             id: choice.value,
@@ -4142,8 +4214,9 @@ export class BridgeManager {
     if (bridge === undefined) {
       bridge = this.makeBridge(def, (b, reason) => {
         this.connectionLost(b, reason)
-      }, (observedAgentId, configOptions) => {
-        this.absorbCatalog(observedAgentId, configOptions)
+      }, (observedAgentId, configOptions, shapeOnly) => {
+        if (shapeOnly) this.absorbCatalogShape(observedAgentId, configOptions)
+        else this.absorbCatalog(observedAgentId, configOptions)
       }, (observedAgentId, commands) => {
         this.absorbCommands(observedAgentId, commands)
       })
@@ -4277,13 +4350,14 @@ export class BridgeManager {
    * Toggle auto-discovery of newly published models. Lightweight like
    * `setExposedModels`: the def is mutated in place (live bridges share the
    * object) and persisted; no process is restarted, and the current selection
-   * is left exactly as it is.
+   * is left exactly as it is. On is the default, so only the opt-out
+   * (`false`) is written to the file.
    */
   async setAutoDiscoverModels(agentId: string, autoDiscoverModels: boolean): Promise<void> {
     const def = this.defsMap.get(agentId)
     if (def === undefined) throw new AcpError('unknown_agent', `acp: agent "${agentId}" is not configured`)
-    if (autoDiscoverModels) def.autoDiscoverModels = true
-    else delete def.autoDiscoverModels
+    if (autoDiscoverModels) delete def.autoDiscoverModels
+    else def.autoDiscoverModels = false
     this.persistAgents()
     this.broadcastExposure(agentId)
   }
@@ -4546,9 +4620,15 @@ export class BridgeManager {
     // `defaultEffort` only when the current value is one of the agent's levels.
     const effort = this.reasoningMeta(agentId)?.defaultEffort
     if (effort !== undefined) out.effort = effort
-    const extraConfigs: Record<string, string> = {}
+    const extraConfigs: Record<string, string | boolean> = {}
     for (const option of catalog.extras ?? []) {
       const value = option.currentValue
+      if (option.kind === 'boolean') {
+        // The catalog encodes a toggle as 'true' / 'false'; the pick stores the
+        // real boolean, exactly like an explicit checkbox click.
+        if (value === 'true' || value === 'false') extraConfigs[option.configId] = value === 'true'
+        continue
+      }
       if (value !== null && value !== undefined && value !== '') extraConfigs[option.configId] = value
     }
     if (Object.keys(extraConfigs).length > 0) out.extraConfigs = extraConfigs
@@ -4602,7 +4682,11 @@ export class BridgeManager {
         if (extraConfigs[configId] !== undefined) continue
         const option = options.extras?.find(entry => entry.configId === configId)
         if (option === undefined) continue
-        if (option.choices.length > 0 && !option.choices.some(choice => choice.value === value)) continue
+        // The fresh session's own option set is the authority for BOTH forms:
+        // a toggle must still be a toggle, a select must still offer the value.
+        if (option.kind === 'boolean'
+          ? typeof value !== 'boolean'
+          : typeof value !== 'string' || (option.choices.length > 0 && !option.choices.some(choice => choice.value === value))) continue
         extraConfigs[configId] = value
         changed = true
       }

package/src/client/acp-ui.tsx

@@ -494,6 +494,12 @@ export interface AcpMenuItem {
   disabled?: boolean
   /** Leading status dot color (agent process state). */
   dot?: string
+  /**
+   * Render as a checkbox row (`menuitemcheckbox`) rather than a radio row.
+   * The advanced base uses it for the agent's boolean config options: one row
+   * whose check IS the current value, whose `id` is the value a click sets.
+   */
+  checkbox?: boolean
 }
 
 /** One titled block of rows. */
@@ -623,15 +629,18 @@ export function AcpMenu({ model, anchor, onPick, onClose }: AcpMenuProps) {
               <button
                 key={`${section.id}/${item.id}`}
                 type="button"
-                role="menuitemradio"
+                role={item.checkbox === true ? 'menuitemcheckbox' : 'menuitemradio'}
                 aria-checked={item.active === true}
                 className={`ntr-acp-menu-item${item.active === true ? ' is-active' : ''}`}
                 disabled={item.disabled === true}
                 onClick={() => { onPick(item.id, section.id) }}
               >
                 {item.dot !== undefined && <span className="ntr-acp-dot" style={{ background: item.dot }} aria-hidden />}
+                {item.checkbox === true && (
+                  <span className={`ntr-acp-check${item.active === true ? ' is-on' : ''}`} aria-hidden>{item.active === true ? '✓' : ''}</span>
+                )}
                 <span className="ntr-acp-menu-item-label">{item.label}</span>
-                {item.active === true && <span className="ntr-acp-tick" aria-hidden>✓</span>}
+                {item.active === true && item.checkbox !== true && <span className="ntr-acp-tick" aria-hidden>✓</span>}
                 {item.detail !== undefined && <span className="ntr-acp-menu-item-detail">{item.detail}</span>}
               </button>
             ))}
@@ -853,6 +862,8 @@ const STYLE = `
 .ntr-acp-seat-sub { color: var(--dsw-alias-text-secondary, #6b7280); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .ntr-acp-dot { width: 7px; height: 7px; border-radius: 50%; flex: none; }
 .ntr-acp-tick { margin-left: auto; color: var(--dsw-alias-state-business-primary, #2563eb); }
+.ntr-acp-check { display: inline-flex; align-items: center; justify-content: center; flex: none; width: 13px; height: 13px; border: 1px solid var(--dsw-alias-border-l2, #d1d5db); border-radius: 3px; font-size: 10px; line-height: 1; color: var(--dsw-alias-state-business-primary, #2563eb); }
+.ntr-acp-check.is-on { border-color: var(--dsw-alias-state-business-primary, #2563eb); }
 .ntr-acp-menu { position: absolute; bottom: calc(100% + 8px); left: 8px; z-index: 100; width: min(360px, 100%); max-height: min(420px, 60vh); display: flex; flex-direction: column; border: 1px solid var(--dsw-alias-border-l2, #d1d5db); border-radius: 10px; background: var(--dsw-alias-bg-layer-1, #fff); box-shadow: 0 12px 32px rgba(0, 0, 0, 0.16); font-size: 12px; overflow: hidden; }
 .ntr-acp-menu-head { padding: 8px 10px 6px; font-weight: 600; display: flex; align-items: center; gap: 6px; }
 .ntr-acp-menu-title { flex: 1; }

package/src/client/panel.tsx

@@ -358,7 +358,7 @@ function payloadEquals(payload: AgentSavePayload, current: AcpAgentDef): boolean
   if (!sameStringArray(payload.allowedCwdRoots ?? [], current.allowedCwdRoots ?? [])) return false
   if (!sameStringMap(payload.env ?? {}, current.env ?? {})) return false
   if (exposureKey(payload.exposedModels) !== exposureKey(current.exposedModels)) return false
-  if ((payload.autoDiscoverModels === true) !== (current.autoDiscoverModels === true)) return false
+  if ((payload.autoDiscoverModels !== false) !== (current.autoDiscoverModels !== false)) return false
   // An absent field means "use the host default" — which is what `current`
   // already resolved to (see `resolvedIdleTimeoutMs`), so it is not a change.
   if (payload.idleTimeoutMs !== undefined && payload.idleTimeoutMs !== current.idleTimeoutMs) return false
@@ -701,7 +701,7 @@ function AgentRow({
     // background resyncs never clobber in-progress checkbox edits.
   }, [serverExposureKey])
 
-  const serverAutoDiscover = detected.currentConfig?.autoDiscoverModels === true
+  const serverAutoDiscover = detected.currentConfig?.autoDiscoverModels !== false
   useEffect(() => {
     // The switch saves itself through the lightweight RPC, so the host is the
     // truth; this keeps the form (and therefore a later full save) in step.
@@ -956,7 +956,7 @@ function initialForm(detected: DetectedAgentInfo, activeAgent: AgentView | undef
     roots,
     envRows: Object.entries(config?.env ?? {}).map(([key, value]) => ({ key, value })),
     exposed: config?.exposedModels === undefined ? undefined : [...config.exposedModels],
-    autoDiscoverModels: config?.autoDiscoverModels === true,
+    autoDiscoverModels: config?.autoDiscoverModels !== false,
     // Prefer the host's resolved value: it is the one actually in effect.
     idleStr: idleText(activeAgent?.idleTimeoutMs ?? config?.idleTimeoutMs),
   }
@@ -1011,7 +1011,9 @@ function buildPayload(form: AgentForm, detected: DetectedAgentInfo, newCustom: b
     ...(form.npmPackage.trim() === '' ? {} : { npmPackage: form.npmPackage.trim() }),
     env,
     ...(form.exposed === undefined ? {} : { exposedModels: form.exposed }),
-    ...(form.autoDiscoverModels ? { autoDiscoverModels: true } : {}),
+    // Auto-discovery is ON by default: only an unchecked switch records the
+    // opt-out, otherwise a full save would silently re-enable it.
+    ...(form.autoDiscoverModels ? {} : { autoDiscoverModels: false }),
     // `''` sends nothing: the host then applies its own default.
     ...(idleRaw === '' || !idleValid(idleRaw) ? {} : { idleTimeoutMs: Number(idleRaw) }),
   }

package/src/client/session-controls.tsx

@@ -347,6 +347,8 @@ export function describeRoute(
 export interface AdvancedOption {
   configId: string
   name: string
+  /** `'boolean'` for an on/off toggle (`value` is `'true'` / `'false'`, no choices). */
+  kind?: 'boolean'
   /** The conversation's pick, else the value the agent reports as current. */
   value?: string
   choices: readonly { id: string; name: string; description?: string }[]
@@ -370,10 +372,14 @@ export function advancedOptions(
   if (catalog === undefined || extras.length === 0) return []
   const picked = choice !== undefined && choice.agentId === catalog.agentId ? choice.extraConfigs : undefined
   return extras.map(option => {
-    const value = picked?.[option.configId] ?? option.currentValue
+    const raw = picked?.[option.configId] ?? option.currentValue
+    // A toggle's catalog value is 'true' / 'false'; a conversation pick stores
+    // the real boolean. Both collapse to the string form the menu speaks.
+    const value = typeof raw === 'boolean' ? (raw ? 'true' : 'false') : raw
     return {
       configId: option.configId,
       name: option.name,
+      ...(option.kind === 'boolean' ? { kind: 'boolean' as const } : {}),
       ...(value === undefined ? {} : { value }),
       choices: option.choices,
     }
@@ -883,16 +889,28 @@ function thoughtSection(context: MenuContext): AcpMenuSection {
  * and the pick would then be read as the primary model axis.
  */
 function advancedSections(context: MenuContext): AcpMenuSection[] {
-  return advancedOptions(context.catalog, context.choice).map(option => ({
-    id: `config:${option.configId}`,
-    title: option.name,
-    items: option.choices.map(choice => ({
-      id: choice.id,
-      label: choice.name,
-      ...(choice.description === undefined ? {} : { detail: choice.description }),
-      active: choice.id === option.value,
-    })),
-  }))
+  return advancedOptions(context.catalog, context.choice).map(option => {
+    if (option.kind === 'boolean') {
+      // A toggle is ONE checkbox row, not an On/Off pair: the row's check is
+      // the current value and the pick sends the OPPOSITE, which `onPick`
+      // forwards verbatim (the host normalizes 'true' / 'false' to a boolean).
+      const checked = option.value === 'true'
+      return {
+        id: `config:${option.configId}`,
+        items: [{ id: checked ? 'false' : 'true', label: option.name, active: checked, checkbox: true }],
+      }
+    }
+    return {
+      id: `config:${option.configId}`,
+      title: option.name,
+      items: option.choices.map(choice => ({
+        id: choice.id,
+        label: choice.name,
+        ...(choice.description === undefined ? {} : { detail: choice.description }),
+        active: choice.id === option.value,
+      })),
+    }
+  })
 }
 
 /**

package/src/client/store.ts

@@ -1565,7 +1565,7 @@ export class AcpStore {
   }
 
   /** Set one of the bound agent's EXTRA config options for one chat session. */
-  async setChatSessionConfig(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void> {
+  async setChatSessionConfig(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void> {
     try {
       await this.call('session/chat-config-set', {
         dshSessionId,

package/src/impl.ts

@@ -226,8 +226,9 @@ export function validateAgentDef(entry: unknown, label = 'agent'): AcpAgentDef {
   const exposedModels = row.exposedModels === undefined
     ? undefined
     : normalizeExposedModels(row.exposedModels, `agent "${id}" exposedModels`, 'bad_config')
-  // Optional boolean; stored only when true (absent and false are the same
-  // "off" state, so the persisted file does not carry noise).
+  // Optional boolean, ON by default. Only the explicit opt-out is stored:
+  // `true` and absent are the same "on" state, so the persisted file does not
+  // carry noise.
   const autoDiscoverModels = row.autoDiscoverModels
   if (autoDiscoverModels !== undefined && typeof autoDiscoverModels !== 'boolean') {
     throw new AcpError('bad_config', `acp: agent "${id}" autoDiscoverModels must be a boolean`)
@@ -249,7 +250,7 @@ export function validateAgentDef(entry: unknown, label = 'agent'): AcpAgentDef {
     cwd: cwd as string | undefined,
     allowedCwdRoots: roots as string[],
     ...(exposedModels !== undefined ? { exposedModels } : {}),
-    ...(autoDiscoverModels === true ? { autoDiscoverModels: true } : {}),
+    ...(autoDiscoverModels === false ? { autoDiscoverModels: false } : {}),
     ...(idleTimeoutMs === undefined ? {} : { idleTimeoutMs: idleTimeoutMs as number }),
   }
 }
@@ -613,24 +614,110 @@ export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
     if (configId === '') continue
     const choices: NonNullable<AcpAgentCatalog['model']>['choices'] = []
     collectCatalogChoices(row.options, choices)
+    // A boolean toggle has no `options` at all; its current value is a JSON
+    // boolean. It is encoded as 'true' / 'false' so the catalog stays
+    // string-typed for every existing reader, and carries `kind` so the
+    // composer renders a checkbox instead of a select.
+    const booleanKind = row.type === 'boolean'
+      || (typeof row.currentValue === 'boolean' && choices.length === 0)
     const option: AcpCatalogOption = {
       configId,
       name: typeof row.name === 'string' && row.name !== '' ? row.name : configId,
-      currentValue: typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
+      ...(booleanKind ? { kind: 'boolean' as const } : {}),
+      currentValue: booleanKind
+        ? row.currentValue === true || row.currentValue === 'true'
+          ? 'true'
+          : row.currentValue === false || row.currentValue === 'false' ? 'false' : null
+        : typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
       choices,
     }
-    if (slot !== undefined) {
+    // A toggle is never a model / thought / mode SELECT: those controls pick
+    // among choices. It belongs to the advanced base, where it is a checkbox.
+    if (slot !== undefined && !booleanKind) {
       out[slot] = option
       continue
     }
     // Choice-less options have nothing to pick; they would render an empty
-    // section in the advanced menu, so they stay out of the catalog entirely.
-    if (choices.length > 0) extras.set(configId, option)
+    // section in the advanced menu, so they stay out of the catalog entirely —
+    // except a boolean, whose whole point is that it has no choices.
+    if (choices.length > 0 || booleanKind) extras.set(configId, option)
   }
   if (extras.size > 0) out.extras = [...extras.values()]
   return out
 }
 
+/**
+ * Fold one per-session option answer's SHAPE into an agent-level catalog.
+ *
+ * `session/set_config_option` answers are often the ONLY place an agent
+ * publishes how its option set changes with the model — opencode offers
+ * `thought_level` (`effort`) just for models with variants and never
+ * re-notifies after a client-driven set — and the composer's thought chip is
+ * driven by the agent-level catalog. What is agent knowledge there is the
+ * SHAPE (which slots exist, which choices they offer); `currentValue` is not:
+ * in a per-session answer it is that session's pick, and promoting it would
+ * turn one conversation's choice into `reasoning.defaultEffort` for every
+ * other one. A merged slot therefore keeps the catalog's known current value
+ * while the observed choices still offer it, and `null` ("the agent's own
+ * default") otherwise. Slots the answer does not mention are left alone — a
+ * different model may still offer them.
+ */
+export function mergeCatalogShape(existing: AcpAgentCatalog | undefined, observed: AcpAgentCatalog): AcpAgentCatalog {
+  const out: AcpAgentCatalog = {}
+  const merge = (prev: AcpCatalogOption | undefined, next: AcpCatalogOption): AcpCatalogOption => {
+    const kept = prev?.currentValue ?? null
+    return {
+      configId: next.configId,
+      name: next.name,
+      ...(next.kind === 'boolean' ? { kind: 'boolean' as const } : {}),
+      // A boolean has no choices to test `kept` against; it keeps the
+      // catalog's known default like any other slot (the answer's value is
+      // still one session's truth, not the agent's).
+      currentValue: kept !== null && (next.choices.length === 0 || next.choices.some(choice => choice.value === kept)) ? kept : null,
+      choices: next.choices,
+    }
+  }
+  for (const slot of ['model', 'thought', 'mode'] as const) {
+    const prev = existing?.[slot]
+    const next = observed[slot]
+    if (next === undefined) {
+      if (prev !== undefined) out[slot] = prev
+      continue
+    }
+    out[slot] = merge(prev, next)
+  }
+  // Extras merge by configId: observed entries refresh their shape, entries
+  // only the earlier answer knew survive (another model may still offer them).
+  const extras = new Map<string, AcpCatalogOption>()
+  for (const option of existing?.extras ?? []) extras.set(option.configId, option)
+  for (const option of observed.extras ?? []) extras.set(option.configId, merge(extras.get(option.configId), option))
+  if (extras.size > 0) out.extras = [...extras.values()]
+  return out
+}
+
+/**
+ * Size ceiling for one `configOptions` answer to be believed. Normal answers
+ * are a few KB (a 500-model catalog is well under this); beyond it the agent is
+ * misbehaving and absorbing/persisting it would turn every notification into
+ * an unbounded write.
+ */
+export const MAX_CONFIG_OPTIONS_BYTES = 1 << 20
+
+/**
+ * Whether a `configOptions` answer may overwrite known state.
+ *
+ * An EMPTY (or absent) answer is a non-answer: observed agents return
+ * `configOptions: []` in intermediate states, and treating that as "this agent
+ * now has no options" would wipe a perfectly good catalog and session
+ * snapshot for a state that passes (the rule OmniTerm settles on for the same
+ * observation — empty sets never overwrite the last known state). Oversized
+ * answers are dropped for the same reason: see {@link MAX_CONFIG_OPTIONS_BYTES}.
+ */
+export function usableConfigOptions(configOptions: unknown): configOptions is unknown[] {
+  if (!Array.isArray(configOptions) || configOptions.length === 0) return false
+  return JSON.stringify(configOptions).length <= MAX_CONFIG_OPTIONS_BYTES
+}
+
 /** Flatten select `options` (plain values or `SessionConfigSelectGroup`s) into choices, deduped by value. */
 function collectCatalogChoices(options: unknown, out: NonNullable<AcpAgentCatalog['model']>['choices']): void {
   if (!Array.isArray(options)) return
@@ -1433,7 +1520,7 @@ export interface AcpManager {
   /** Switch the reasoning effort for one chat session (agentId names the default-agent case). */
   setChatSessionEffort?(dshSessionId: string, effort: string | undefined, agentId?: string): Promise<void>
   /** Set one of the agent's EXTRA config options for one chat session. */
-  setChatSessionConfig?(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void>
+  setChatSessionConfig?(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void>
   /**
    * State of the ACP-mode agent preset in the harness's OWN roster. Read-only
    * report for the settings panel: the preset is a declaration this package
@@ -1604,8 +1691,12 @@ export async function dispatchRpc(manager: AcpManager, endpoint: string, payload
       case 'session/chat-config-set': {
         const dshSessionId = str(body, 'dshSessionId', 128)
         const configId = str(body, 'configId', 128)
-        const value = str(body, 'value', 512)
-        await manager.setChatSessionConfig?.(dshSessionId, configId, value, optionalStr(body, 'agentId', 64))
+        const value = body.value
+        if (typeof value === 'boolean') {
+          await manager.setChatSessionConfig?.(dshSessionId, configId, value, optionalStr(body, 'agentId', 64))
+          return ok({ done: true })
+        }
+        await manager.setChatSessionConfig?.(dshSessionId, configId, str(body, 'value', 512), optionalStr(body, 'agentId', 64))
         return ok({ done: true })
       }
       case 'preset/status':