dsh-hypatia-auto-memory 1.1.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-hypatia-auto-memory",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Event-driven Hypatia memory for DSH: automatic conversation logging via session events, queued background consolidation (span summaries + work-unit extraction) with a dedicated model route, and recall injection — zero per-call model work in the main session.",
   "type": "module",
   "main": "src/index.js",
@@ -62,6 +62,8 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
+    "@deepseek-ai/dsh-agent": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-api-remotes": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-api-session-controller": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-client-locale": "^0.1.7-rc.1",
@@ -73,7 +75,10 @@
     "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-llm": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.1",
     "@deepseek-ai/dsh-storage-domain": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-tools": "^0.1.7-rc.1",
+    "@deepseek-ai/dsh-user-approval": "^0.1.7-rc.1",
     "@types/react": "^18.2.0",
     "lightningcss": "^1.32.0",
     "react": "^18.2.0",

package/src/cascade.js

@@ -21,8 +21,9 @@
 
 import { createHash } from 'node:crypto'
 
-import { PLUGIN_NAME, outputBudget } from './consolidator.js'
+import { PLUGIN_NAME, budgetForEffort } from './consolidator.js'
 import { NULL_MODEL_LOG } from './model-log.js'
+import { createReasoningResolver } from './reasoning.js'
 
 /** Tag marking the tier an entry belongs to. */
 export function levelTag(level) {
@@ -78,31 +79,39 @@ function archiveInstruction(level, count) {
  * @param {{
  *   cli: ReturnType<import('./hypatia-client.js').createHypatiaClient>,
  *   llm: any,
- *   selectRoute: (routes: any) => any,
+ *   selectRoute: (routes: any, attempt?: number) => any,
  *   getConfig: () => any,
  *   status: import('./status.js').StatusLog,
  *   modelLog?: ReturnType<import('./model-log.js').createModelLog>,
- * }} deps
+ *   reasoning?: ReturnType<import('./reasoning.js').createReasoningResolver>,
+ * }} deps - `reasoning` is shared with the consolidator (index.js), so one
+ * capability cache and one set of warnings cover both executors.
  */
-export function createCascade({ cli, llm, selectRoute, getConfig, status, modelLog = NULL_MODEL_LOG }) {
+export function createCascade({ cli, llm, selectRoute, getConfig, status, modelLog = NULL_MODEL_LOG, reasoning }) {
+  const effortFor = reasoning ?? createReasoningResolver({ llm, status })
+
   /**
    * Ask the model to archive one batch.
+   *
+   * @param {string | undefined} effort - the resolved thinking level for this
+   * run, decided once in `execute` so every tier is archived the same way.
    * @returns {Promise<{title: string, summary: string} | undefined>}
    */
-  async function archiveBatch(level, rows, route, timeoutMs) {
+  async function archiveBatch(level, rows, route, timeoutMs, effort) {
     const body = rows.map((row, i) => {
       const data = typeof row?.content?.data === 'string' ? row.content.data : ''
       return `### ${i + 1}. ${row.name}\n${data}`
     }).join('\n\n')
 
-    const attempt = modelLog.begin('memory-cascade', route)
+    const attempt = modelLog.begin('memory-cascade', route, effort)
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), timeoutMs)
     let outcome = 'incomplete'
     let detail = ''
+    let assembler
     try {
       const { createUserMessage, BlockAssembler } = await import('@deepseek-ai/dsh-llm')
-      const assembler = new BlockAssembler()
+      assembler = new BlockAssembler()
       for await (const chunk of llm.stream({
         provider: route.provider,
         model: route.model,
@@ -111,14 +120,18 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status, modelL
           content: [{ type: 'text', text: `${archiveInstruction(level, rows.length)}\n\n${body}` }],
           source: { kind: 'plugin', plugin: PLUGIN_NAME },
         })],
-        // Thinking stays ON here, unlike the extraction call: an archive is a
-        // semantic compression of sixteen summaries, not a mechanical transform
-        // into a fixed shape, and reasoning plausibly earns its cost. What it
-        // must not do is share a cap sized for the answer alone, so the budget
-        // carries the thinking allowance. (This call fails SOFT — a truncated
-        // archive just returns undefined and the tier is retried by the next
-        // batch — which is why the permanent-failure path never applied to it.)
-        maxTokens: outputBudget(getConfig().consolidation.maxOutputTokens, false),
+        // Thinking stays ON by default here, unlike the extraction call: an
+        // archive is a semantic compression of sixteen summaries, not a
+        // mechanical transform into a fixed shape, and reasoning plausibly earns
+        // its cost. So the purpose policy asks for nothing and leaves the
+        // adapter's own default in place — unless the route's configuration
+        // named a level, which `effortFor` resolved above. Either way the budget
+        // carries the thinking allowance unless the level is `off`. (This call
+        // fails SOFT — a truncated archive just returns undefined and the tier
+        // is retried by the next batch — which is why the permanent-failure path
+        // never applied to it.)
+        maxTokens: budgetForEffort(getConfig().consolidation.maxOutputTokens, effort),
+        ...effort === undefined ? {} : { reasoningEffort: effort },
         purpose: 'memory-cascade',
         signal: controller.signal,
       })) {
@@ -155,7 +168,9 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status, modelL
       throw error
     } finally {
       clearTimeout(timer)
-      void attempt.finish(outcome, detail)
+      // Read even on a throw: a truncated archive is the case whose token split
+      // is worth having.
+      void attempt.finish(outcome, detail, assembler?.usage)
     }
   }
 
@@ -163,15 +178,20 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status, modelL
    * Run the cascade for one project, from tier 2 upward, until a tier has fewer
    * than `batchSize` unarchived entries.
    *
-   * @param {{project: string}} task
+   * @param {{project: string, attempts?: number}} task
    */
   async function execute(task) {
     const config = getConfig()
     const consolidation = config.consolidation
     if (consolidation.cascade?.enabled === false) return
     const batchSize = consolidation.cascade?.batchSize ?? 16
-    const route = selectRoute(consolidation.models)
+    // Same priority order as consolidation: the first attempt archives on the
+    // preferred route, a retry degrades. The run picks once and archives every
+    // tier with that one choice — and resolves its thinking level once, the same
+    // way, so a multi-tier climb cannot change personality halfway.
+    const route = selectRoute(consolidation.models, task.attempts)
     if (route === undefined) return
+    const effort = await effortFor.effort(route, 'memory-cascade')
 
     // A ceiling on tiers, not an expected depth: reaching tier 8 at 16:1 would
     // mean ~4 billion source entries. It exists so a malformed shelf cannot spin.
@@ -192,7 +212,7 @@ export function createCascade({ cli, llm, selectRoute, getConfig, status, modelL
 
       const existing = await cli.knowledgeGet(name)
       if (existing.found === false) {
-        const archived = await archiveBatch(level, rows, route, consolidation.timeoutMs)
+        const archived = await archiveBatch(level, rows, route, consolidation.timeoutMs, effort)
         if (archived === undefined) {
           status.warn(`cascade archive produced nothing usable at tier ${level}`)
           return

package/src/client/SettingsCard.module.css

@@ -334,6 +334,89 @@
   background: var(--dsw-alias-bg-layer-4);
 }
 
+/* Flex, not a grid: the availability badge is absent on most rows, and a fixed
+   template would shift the action buttons by one column when it disappears. */
+.selectedRow {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  border-radius: 6px;
+  padding: 6px;
+}
+
+.selectedRow:hover {
+  background: var(--dsw-alias-bg-layer-4);
+}
+
+.order {
+  min-width: 16px;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+}
+
+.selectedText {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+/* Compact on purpose: one per priority row, and the row already carries an
+   ordinal, a name, a route, an availability badge and three buttons. */
+.effort {
+  flex: 0 0 auto;
+  max-width: 132px;
+  padding: 2px 4px;
+  border: 0.5px solid var(--dsw-alias-border-l4);
+  border-radius: 5px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  cursor: pointer;
+  font: inherit;
+  font-size: 12px;
+}
+
+.effort:disabled {
+  cursor: default;
+  opacity: 0.5;
+}
+
+.effort:focus-visible {
+  border-color: var(--dsw-alias-brand-primary);
+  outline: none;
+}
+
+.rowActions {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.move {
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  border: 0.5px solid var(--dsw-alias-border-l4);
+  border-radius: 5px;
+  background: transparent;
+  color: var(--dsw-alias-label-secondary);
+  cursor: pointer;
+  font: inherit;
+  font-size: 12px;
+  line-height: 1;
+}
+
+.move:hover:not(:disabled) {
+  background: var(--dsw-alias-bg-layer-4);
+  color: var(--dsw-alias-label-primary);
+}
+
+.move:disabled {
+  cursor: default;
+  opacity: 0.4;
+}
+
 .modelName,
 .route {
   display: block;

package/src/client/SettingsCard.tsx

@@ -14,9 +14,13 @@ import type { ConfigForm, ConfigFormSnapshot } from '@deepseek-ai/dsh-client-ui-
 import {
   consolidationModelCandidates,
   consolidationModelKey,
+  moveConsolidationModel,
+  orderedConsolidationModels,
+  reasoningEffortChoices,
   type ConsolidationModelCandidate,
   type ConsolidationModelRoute,
   type LoadConsolidationModelCatalog,
+  type ReasoningEffortChoice,
 } from './consolidation-models'
 import { DEFAULT_SHELF, shelfChoices, type LoadShelfInventory, type ShelfInfo } from './shelves'
 import css from './SettingsCard.module.css'
@@ -180,6 +184,13 @@ export function SettingsCard({ scope, loadModelCatalog, loadShelfInventory, t }:
     )
   }, [catalogGroups, consolidation.models])
 
+  // The draft's own order, NOT the catalog's: this list is what the Host reads
+  // as the priority order, so it has to show the stored array verbatim.
+  const selectedModels = useMemo(
+    () => orderedConsolidationModels(consolidation.models ?? [], candidates),
+    [consolidation.models, candidates],
+  )
+
   const toggleModel = useCallback((candidate: ConsolidationModelCandidate) => {
     if (disabled || saving) return
     setDraft((current) => {
@@ -197,6 +208,75 @@ export function SettingsCard({ scope, loadModelCatalog, loadShelfInventory, t }:
     })
   }, [disabled, saving])
 
+  /**
+   * Reorder one entry of the priority list. A no-op move leaves the draft
+   * untouched (the mover returns the original array), so the "unsaved" badge
+   * does not light up for a click that changed nothing.
+   */
+  const moveModel = useCallback((from: number, to: number) => {
+    if (disabled || saving) return
+    setDraft((current) => {
+      const currentConsolidation = current.consolidation ?? DEFAULT_CONSOLIDATION
+      const currentModels = currentConsolidation.models ?? []
+      const models = moveConsolidationModel(currentModels, from, to)
+      if (models === currentModels) return current
+      return {
+        ...current,
+        consolidation: { ...currentConsolidation, models },
+      }
+    })
+  }, [disabled, saving])
+
+  /**
+   * Set or clear one route's thinking level. Clearing REMOVES the key rather
+   * than storing `undefined`, so the saved patch carries only what the user
+   * chose and nothing reading the profile can confuse "not configured" with
+   * "configured as nothing".
+   */
+  const setModelEffort = useCallback((index: number, effort: string | undefined) => {
+    if (disabled || saving) return
+    setDraft((current) => {
+      const currentConsolidation = current.consolidation ?? DEFAULT_CONSOLIDATION
+      const currentModels = currentConsolidation.models ?? []
+      if (index < 0 || index >= currentModels.length) return current
+      const models = currentModels.map((route, at) => {
+        if (at !== index) return route
+        if (effort === undefined) {
+          const cleared = { ...route }
+          delete cleared.reasoningEffort
+          return cleared
+        }
+        return { ...route, reasoningEffort: effort }
+      })
+      return {
+        ...current,
+        consolidation: { ...currentConsolidation, models },
+      }
+    })
+  }, [disabled, saving])
+
+  /** Display label for one thinking-level option, in the card's own words. */
+  const effortChoiceLabel = useCallback((choice: ReasoningEffortChoice): string => {
+    if (choice.effort === undefined) return t('reasoningFollowPurpose')
+    const name = choice.name ?? choice.effort
+    // A value the route no longer declares is shown, not hidden: rewriting the
+    // user's configuration behind their back is worse than showing a stale one.
+    return choice.stale === true ? `${name} · ${t('reasoningStale')}` : name
+  }, [t])
+
+  /**
+   * What the adapter does when no effort is sent. Only a hint: this plugin
+   * cannot pin it, because omitting the field is what lets its own per-purpose
+   * policy apply.
+   */
+  const routeDefaultLabel = useCallback((candidate: ConsolidationModelCandidate): string | undefined => {
+    const reasoning = candidate.reasoning
+    const fallback = reasoning?.defaultEffort
+    if (reasoning === undefined || fallback === undefined) return undefined
+    const named = reasoning.efforts.find(effort => effort.id === fallback)
+    return t('reasoningDefault', { effort: named?.name ?? fallback })
+  }, [t])
+
   const discard = useCallback(() => {
     setDraft(resolved)
     setError(null)
@@ -411,22 +491,87 @@ export function SettingsCard({ scope, loadModelCatalog, loadShelfInventory, t }:
             ) : null}
             {catalogPartial ? <p className={css.notice}>{t('modelCatalogPartial')}</p> : null}
             {candidates.length > 0 ? (
-              <fieldset className={css.models}>
-                <legend>{t('selectedModels')}</legend>
-                {[...availableGroups].map(([provider, group]) => (
-                  <div key={provider} className={css.modelGroup}>
-                    <div className={css.providerName}>{group.providerName}</div>
-                    {group.candidates.map(renderCandidate)}
-                  </div>
-                ))}
-                {unavailable.length > 0 ? (
-                  <div className={css.modelGroup}>
-                    <div className={css.providerName}>{t('unavailableModels')}</div>
-                    {unavailable.map(renderCandidate)}
-                  </div>
-                ) : null}
-              </fieldset>
+              <>
+                <fieldset className={css.models}>
+                  <legend>{t('selectedModels')}</legend>
+                  {selectedModels.length === 0 ? (
+                    <p className={css.notice}>{t('selectedModelsEmpty')}</p>
+                  ) : selectedModels.map((candidate, index) => (
+                    <div key={candidate.key} className={css.selectedRow}>
+                      <span className={css.order}>{index + 1}</span>
+                      <span className={css.selectedText}>
+                        <span className={css.modelName}>{candidate.modelName}</span>
+                        <span className={css.route}>{`${candidate.providerName} · ${candidate.provider}/${candidate.model}`}</span>
+                      </span>
+                      <select
+                        className={css.effort}
+                        aria-label={`${t('reasoningEffort')}: ${candidate.modelName}`}
+                        title={candidate.reasoning === undefined
+                          ? t('reasoningUnavailable')
+                          : routeDefaultLabel(candidate) ?? t('reasoningFollowPurpose')}
+                        value={candidate.reasoningEffort ?? ''}
+                        disabled={disabled || saving || candidate.reasoning === undefined}
+                        onChange={(event) => setModelEffort(index, event.target.value === '' ? undefined : event.target.value)}
+                      >
+                        {reasoningEffortChoices(candidate.reasoning, candidate.reasoningEffort).map(choice => (
+                          <option key={choice.key} value={choice.effort ?? ''}>{effortChoiceLabel(choice)}</option>
+                        ))}
+                      </select>
+                      {!candidate.available ? <span className={css.unavailable}>{t('modelUnavailable')}</span> : null}
+                      <span className={css.rowActions}>
+                        <button
+                          type="button"
+                          className={css.move}
+                          title={t('moveUp')}
+                          aria-label={`${t('moveUp')}: ${candidate.modelName}`}
+                          disabled={disabled || saving || index === 0}
+                          onClick={() => moveModel(index, index - 1)}
+                        >
+                          ↑
+                        </button>
+                        <button
+                          type="button"
+                          className={css.move}
+                          title={t('moveDown')}
+                          aria-label={`${t('moveDown')}: ${candidate.modelName}`}
+                          disabled={disabled || saving || index === selectedModels.length - 1}
+                          onClick={() => moveModel(index, index + 1)}
+                        >
+                          ↓
+                        </button>
+                        <button
+                          type="button"
+                          className={css.move}
+                          title={t('remove')}
+                          aria-label={`${t('remove')}: ${candidate.modelName}`}
+                          disabled={disabled || saving}
+                          onClick={() => toggleModel(candidate)}
+                        >
+                          ×
+                        </button>
+                      </span>
+                    </div>
+                  ))}
+                </fieldset>
+
+                <fieldset className={css.models}>
+                  <legend>{t('availableModels')}</legend>
+                  {[...availableGroups].map(([provider, group]) => (
+                    <div key={provider} className={css.modelGroup}>
+                      <div className={css.providerName}>{group.providerName}</div>
+                      {group.candidates.map(renderCandidate)}
+                    </div>
+                  ))}
+                  {unavailable.length > 0 ? (
+                    <div className={css.modelGroup}>
+                      <div className={css.providerName}>{t('unavailableModels')}</div>
+                      {unavailable.map(renderCandidate)}
+                    </div>
+                  ) : null}
+                </fieldset>
+              </>
             ) : catalogStatus === 'ready' ? <p className={css.notice}>{t('modelCatalogEmpty')}</p> : null}
+            <p className={css.hint}>{t('reasoningBudgetHint')}</p>
           </div>
 
           <div className={css.pairedFields}>

package/src/client/consolidation-models.ts

@@ -1,11 +1,39 @@
-/** Model-directory projection shared by the consolidation settings card. */
+/**
+ * Model-directory projection shared by the consolidation settings card.
+ *
+ * Two projections of the same data, deliberately kept apart: the CATALOG one
+ * (every advertised route, in directory order, with a `selected` flag) is the
+ * pool a user picks from, and the ORDERED one (the stored array as-is) is the
+ * priority list consolidation actually reads. Directory order must never leak
+ * into the latter — it did, and the card then showed a rotation order the
+ * configuration did not have.
+ */
 
 import type { ModelProviderGroup } from '@deepseek-ai/dsh-api-remotes/client'
 
+/**
+ * Adapter-owned reasoning metadata for one catalog model. Derived from the
+ * catalog type rather than re-declared, so a change upstream cannot drift from
+ * what the card renders: `efforts` is the vocabulary the adapter accepts, in its
+ * own preferred display order, and `defaultEffort` (optional) is what the
+ * adapter materializes when a caller omits an effort.
+ */
+export type ConsolidationModelReasoning = NonNullable<ModelProviderGroup['models'][number]['reasoning']>
+
 /** One exact provider/model route used for a consolidation attempt. */
 export interface ConsolidationModelRoute {
   provider: string
   model: string
+  /**
+   * Optional thinking level for this route. Absent means "follow the purpose
+   * policy", which is what every call did before the field existed: extraction
+   * and adjudication ask for no reasoning where the route allows it, and the
+   * archive call leaves the adapter's own default in place.
+   *
+   * The vocabulary is adapter-owned and opaque, so the card only ever offers
+   * what this model's catalog entry declares.
+   */
+  reasoningEffort?: string
 }
 
 /** One catalog route, including stored routes no longer advertised by an adapter. */
@@ -15,6 +43,20 @@ export interface ConsolidationModelCandidate extends ConsolidationModelRoute {
   modelName: string
   available: boolean
   selected: boolean
+  /** Absent for a route the catalog no longer advertises. */
+  reasoning?: ConsolidationModelReasoning
+}
+
+/** One row of the thinking-level picker. */
+export interface ReasoningEffortChoice {
+  /** Stable key for React and for tests. */
+  key: string
+  /** Value to store; `undefined` means "follow the purpose policy". */
+  effort: string | undefined
+  /** Adapter-provided display name; the card supplies its own label when absent. */
+  name?: string
+  /** The stored value is no longer declared by this route. */
+  stale?: boolean
 }
 
 /** One catalog response retained by the settings card. */
@@ -31,6 +73,110 @@ export function consolidationModelKey(route: ConsolidationModelRoute): string {
   return `${route.provider}\0${route.model}`
 }
 
+/**
+ * Move one entry of the priority list, returning a new array.
+ *
+ * The stored `consolidation.models` array IS the priority order, so this is the
+ * only thing a reorder has to do: reorder the array. `to` is clamped instead of
+ * rejected, so a click that cannot move anything (the first row's "up") is a
+ * no-op rather than an error. A no-op returns the ORIGINAL reference, which lets
+ * a caller use identity to skip the state update.
+ *
+ * @param models - Priority-ordered routes; not mutated.
+ * @param from - Index to move.
+ * @param to - Target index, clamped into `models`.
+ */
+export function moveConsolidationModel(
+  models: ConsolidationModelRoute[],
+  from: number,
+  to: number,
+): ConsolidationModelRoute[] {
+  if (!Number.isInteger(from) || from < 0 || from >= models.length) return models
+  if (!Number.isFinite(to)) return models
+  const target = Math.min(Math.max(0, Math.trunc(to)), models.length - 1)
+  if (target === from) return models
+  const next = [...models]
+  const [moved] = next.splice(from, 1)
+  next.splice(target, 0, moved)
+  return next
+}
+
+/**
+ * The stored routes in their configured (priority) order, each resolved to its
+ * catalog entry for a display name, an availability flag and the reasoning
+ * levels the route declares.
+ *
+ * `consolidationModelCandidates` already guarantees every stored route appears —
+ * taken from the catalog, or appended as unavailable — so the candidate list is
+ * a lookup table for this. A route that somehow is not in it is still shown,
+ * named by its raw ids and marked unavailable, because dropping it from the
+ * priority list would hide a configured route from the only UI that can remove
+ * it.
+ *
+ * `reasoningEffort` is taken from the STORED route, never from the catalog: the
+ * catalog describes what a model can do, the stored route is what the user chose.
+ */
+export function orderedConsolidationModels(
+  stored: readonly ConsolidationModelRoute[],
+  candidates: readonly ConsolidationModelCandidate[],
+): ConsolidationModelCandidate[] {
+  const byKey = new Map(candidates.map(candidate => [candidate.key, candidate]))
+  return stored.map((route) => {
+    const key = consolidationModelKey(route)
+    const base = byKey.get(key) ?? {
+      ...route,
+      key,
+      providerName: route.provider,
+      modelName: route.model,
+      available: false,
+      selected: true,
+    }
+    return { ...base, reasoningEffort: route.reasoningEffort }
+  })
+}
+
+/**
+ * The thinking-level options for one route, in the order they are offered.
+ *
+ * Two rules, both about not inventing a vocabulary this plugin does not own:
+ *
+ * - The list comes from the route's own declared `efforts`, in the adapter's
+ *   preferred order, labelled with the adapter's own names. Nothing is
+ *   hard-coded — the ids are opaque, and a level one adapter accepts is not one
+ *   another does.
+ * - "Follow the purpose policy" (`undefined`) is always first and is what an
+ *   absent field stores. It is NOT the same as the adapter's `defaultEffort`:
+ *   omitting the field lets the plugin's own per-purpose policy apply, which for
+ *   extraction and adjudication means asking for no reasoning at all.
+ *
+ * A stored value the route no longer declares is appended and flagged rather
+ * than dropped, so the card can show what is actually configured instead of
+ * silently rewriting it — and so a route whose catalog entry disappeared still
+ * displays its setting.
+ *
+ * @param reasoning - The route's catalog metadata; absent when the catalog does
+ * not advertise the route, or the model declares no reasoning control.
+ * @param stored - The configured value, if any.
+ */
+export function reasoningEffortChoices(
+  reasoning: ConsolidationModelReasoning | undefined,
+  stored: string | undefined,
+): ReasoningEffortChoice[] {
+  const efforts = Array.isArray(reasoning?.efforts) ? reasoning.efforts : []
+  const choices: ReasoningEffortChoice[] = [{ key: 'purpose', effort: undefined }]
+  for (const effort of efforts) {
+    const id = typeof effort?.id === 'string' ? effort.id : ''
+    if (id === '') continue
+    const name = typeof effort.name === 'string' && effort.name !== '' ? effort.name : id
+    choices.push({ key: `effort:${id}`, effort: id, name })
+  }
+  const value = typeof stored === 'string' ? stored.trim() : ''
+  if (value !== '' && !efforts.some(effort => effort?.id === value)) {
+    choices.push({ key: `stale:${value}`, effort: value, stale: true })
+  }
+  return choices
+}
+
 /**
  * Join the live model directory with selected routes that disappeared from it.
  * Disappeared routes remain visible so users can remove them deliberately.
@@ -52,6 +198,10 @@ export function consolidationModelCandidates(
       modelName: model.name,
       available: true,
       selected: selected.has(key),
+      // The adapter-owned vocabulary this route accepts, straight from the
+      // catalog the card already loaded — no extra request, and no client-side
+      // guess at what "low" or "high" mean.
+      ...model.reasoning === undefined ? {} : { reasoning: model.reasoning },
     }
   }))
   for (const route of storedByKey.values()) {