diff --git a/package.json b/package.json
index 9f79eed..e1db4fe 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",
diff --git a/src/config-flow.ts b/src/config-flow.ts
index cffb0c4..82842db 100644
--- a/src/config-flow.ts
+++ b/src/config-flow.ts
@@ -33,8 +33,14 @@
  *   3. `editor`  — the widget for one field: a one-keystroke `select` for a
  *                  boolean, a `prompt` for a number or a string, the grouped
  *                  provider picker for a model reference.
- *   4. `search`  — reached from the hub's own second row, so it is one escape
- *                  from the hub rather than a fourth level to climb out of.
+ *
+ * THERE IS NO SEARCH SCREEN, and the host is why. Every `ui.dialog.select` draws
+ * the host's own fuzzy filter over `title` and `category` (weighted 2:1 toward
+ * the title), live, above the list — see `dialog-select.tsx`'s `filtered`. A
+ * `search` screen added on top of that had to be ENTERED first, which meant a
+ * keystroke before a keystroke, and its own substring filter over labels and
+ * paths that was strictly worse than the fuzzy match already running underneath
+ * it. A second search box over a searchable list is not a feature.
  *
  * ESCAPE IS "GO UP ONE LEVEL", EVERYWHERE, AND IT NEVER DISCARDS SILENTLY — the
  * draft lives in memory and nothing has been written, so escaping from an editor
@@ -166,13 +172,10 @@ export type ConfigDraft = Record<string, unknown>
  * question "can the user get out of here" has to be answerable, and it cannot
  * be answered for something that is not a state.
  *
- * `search` is a screen for the same reason, and it is only ONE level above the
- * hub so that the "at most two escapes to the hub" guarantee survives it: a
- * search that took three to leave would be a feature that can strand someone.
+ * THREE KINDS, and there is no fourth: filtering is the host's, not a screen.
  */
 export type ConfigScreen =
   | { readonly kind: 'blocks' }
-  | { readonly kind: 'search'; readonly query: string }
   | { readonly kind: 'fields'; readonly block: string }
   | { readonly kind: 'editor'; readonly field: ConfigField }
 
@@ -508,7 +511,6 @@ export function configDirtyCount(
  * honest thing is to drop it and re-add it when there is a title to vary.
  */
 export function configScreenTitle(screen: ConfigScreen, changes: number): string {
-  if (screen.kind === 'search') return `Nexus configuration — search "${screen.query}"`
   if (screen.kind === 'fields') return `Nexus configuration — ${screen.block}`
   if (screen.kind === 'editor') {
     return `Nexus configuration — ${configPathLabel(screen.field.path)}`
@@ -705,14 +707,6 @@ export function configOptionTitle(option: ConfigOption, scope: ConfigScope): str
       return option.block.name
     case 'field':
       return option.field.label
-    case 'search':
-      return '🔍 Search settings…'
-    case 'no-results':
-      // QUOTES the query. A miss whose row says only "no results" cannot be told
-      // from a typo by a user who does not remember what they typed, and the
-      // quotes make a query containing a space or a dot read as the one thing it
-      // is rather than as a sentence.
-      return `No setting matches "${option.query}"`
     case 'switch':
       // The direction is in WORDS. The glyph is reinforcement, not the carrier:
       // a host that dropped it, or rendered it monochrome, would still leave a
@@ -728,26 +722,61 @@ export function configOptionTitle(option: ConfigOption, scope: ConfigScope): str
 }
 
 /**
- * What a row says underneath itself, which is where the CURRENT value lives.
+ * A field's ADDRESS, relative to its own block, or `undefined` when the label
+ * already is the address.
+ *
+ * The description of a field row, and the reason it is not the block name: the
+ * dialog's title already says which block this is, so repeating `gitFlow` on
+ * every one of its four rows is ink that says nothing. What the label alone
+ * cannot carry is the NESTING — `customRoles[0].model` and `customRoles[7].model`
+ * are both labelled `model`, and a list of identical rows is a list nobody can
+ * pick from. So the path is given, minus the prefix the title is already showing,
+ * and only when there is a prefix worth giving.
+ */
+export function configFieldContext(field: ConfigField): string | undefined {
+  // SEGMENTS, not a string prefix. The segment after the block is not always a
+  // key: for `customRoles[0].model` the second segment is the INDEX `0`, so
+  // `full.startsWith('customRoles.')` is false and a prefix implementation drops
+  // the context for exactly the fields that need it most.
+  if (field.path[0] !== field.block) return undefined
+  const rest = field.path.slice(1)
+  if (rest.length === 0) return undefined
+  const context = configPathLabel(rest)
+  // A field directly under its block has a context that IS its label:
+  // `budget.maxTotalCost` minus `budget.` is `maxTotalCost`, and the title of the
+  // field list is already `Nexus configuration — budget`. Printing it would put
+  // the row's own name next to itself. Only a NESTED field earns the slot.
+  return context === field.label ? undefined : context
+}
+
+/**
+ * What a row says BESIDE ITSELF, which is the HOST's muted inline slot.
+ *
+ * ── THE ROUTING, AND WHY IT IS NOT NEGOTIABLE ──
  *
- * A block's row counts its fields, because a list of eight block names tells a
- * user nothing about which one holds the setting they are looking for. A field's
- * row shows its value AND whether it has been changed since the flow opened —
- * the dialog equivalent of the panel's `*`, and the only way a staged edit is
- * visible before the save that commits it.
+ * The host gives every row three text slots and they are not the same slot:
+ * `description` renders muted and INLINE immediately after the title,
+ * `footer` renders muted and RIGHT-ALIGNED after the flexing title, and
+ * `category` becomes a bold accent group header above the row. So:
+ *
+ *   title       what the row IS                — `maxTotalCost`, `budget`
+ *   description what disambiguates it          — the nested path, what is not
+ *                                                editable here, what a choice does
+ *   footer      its CURRENT STATE, right-aligned — the value, the settings count,
+ *                                                the dirty marker
+ *
+ * A value in a `description` reads as a parenthetical about the setting, and
+ * that is what it used to be: `maxTotalCost 10` on one line, with every row's
+ * value starting at a different column, so the one thing a user scans this list
+ * for was the one thing that would not line up. In a `footer` the values right-
+ * align into a column of their own and the labels into another, which is what
+ * the host's own lists (`DialogSelectOption.footer`) are for.
  *
  * `base` is REQUIRED, not defaulted. It is the only way a row can say how much
  * has changed, and an omitted argument defaulted to `draft` would report `0
  * changed` for every block on every save — a plausible-looking lie rather than a
  * type error, and the harder of the two to notice. A required parameter makes
  * the call site fail to compile instead, which is the correct time to find out.
- *
- * EVERY DIRTY MARKER CARRIES A NUMBER as well as its glyph. The `*` is a glyph:
- * it survives colour loss, a narrow font and a monochrome terminal, but it does
- * not say HOW MUCH, and "which block did I change" is a question a count
- * answers and a star does not. Where the number would be 0 or 1 it is left off
- * instead — a field row reading `true  *  1 changed` is noise, and a block with
- * one edit does not need a count to be found.
  */
 export function configOptionDescription(
   option: ConfigOption,
@@ -755,30 +784,42 @@ export function configOptionDescription(
   base: ConfigDraft,
   dirty: boolean,
   changes?: number
-): string {
+): string | undefined {
   switch (option.kind) {
     case 'scope':
       return 'Nothing is written until you choose Save'
-    case 'search':
-      return 'Find a setting by block or name'
-    case 'no-results':
-      return 'Searches block names and setting names'
     case 'block': {
-      const count = option.block.fields.length
+      // THE UNEDITABLE COUNT LIVES HERE, and it is here because of what the host
+      // does with `disabled`, not because this is the tidiest sentence. The host
+      // FILTERS a `disabled` row out of the list — `filtered()` drops
+      // `x.disabled !== true` before anything is drawn — so a field the flow has
+      // no editor for is not dimmed, it is GONE. A block row that said only "3
+      // settings" would then be claiming three settings and showing two, and the
+      // missing one is indistinguishable from a key this flow never walked. The
+      // count on the BLOCK is the only place the fact can honestly live: it is
+      // the row that survives, and it is the row a user reads before choosing to
+      // go in. Zero for every block shipped today, which is why this is a
+      // sentence that mostly says nothing.
+      const uneditable = uneditableBlockCount(option.block)
+      const parts: string[] = []
+      if (uneditable > 0) {
+        parts.push(`${uneditable} ${uneditable === 1 ? 'setting' : 'settings'} not editable here`)
+      }
       // The empty case is said out loud. `customRoles` is empty on a fresh
       // install, and a list holding nothing but "← Back" reads as a screen that
       // failed to load rather than as a block with nothing in it.
-      if (count === 0) {
-        return 'no settings here yet — add custom roles in nexus.jsonc'
+      if (option.block.fields.length === 0) {
+        parts.push('no settings here yet — add custom roles in nexus.jsonc')
       }
-      const changed = configBlockDirtyCount(option.block, base, draft)
-      return changed === 0
-        ? `${count} ${count === 1 ? 'setting' : 'settings'}`
-        : `${count} ${count === 1 ? 'setting' : 'settings'}  ${changed} changed  *`
+      return parts.length === 0 ? undefined : parts.join(' · ')
     }
     case 'field': {
-      const value = describeConfigValue(configValueAt(draft, option.field.path))
-      return dirty ? `${value}  *` : value
+      const context = configFieldContext(option.field)
+      if (context !== undefined) return context
+      // A top-level field's label IS its address once the title has named the
+      // block, so there is nothing to add — and a description reading
+      // `maxTotalCost` under a title reading `maxTotalCost` is noise.
+      return undefined
     }
     case 'switch':
       return option.value
@@ -808,6 +849,115 @@ export function configOptionDescription(
   }
 }
 
+/**
+ * Whether THIS field's value differs between `base` and `draft`.
+ *
+ * A per-FIELD question, asked with the same structural comparison
+ * `configIsDirty` and `configBlockDirtyCount` use, so "a row is marked" and
+ * "the config is dirty" cannot be two different notions of equality.
+ *
+ * The adapter has a whole-draft `configIsDirty` boolean and it is the WRONG
+ * input for a row. It is one bit about the entire config, and using it to mark
+ * a single field's row means staging one edit marks every field in the block. A
+ * marker on rows the user did not touch is worse than no marker, because a user
+ * who cannot trust the `*` also cannot use it to find what they changed.
+ */
+export function configFieldDirty(
+  field: ConfigField,
+  base: ConfigDraft,
+  draft: ConfigDraft
+): boolean {
+  return !configSameValue(configValueAt(base, field.path), configValueAt(draft, field.path))
+}
+
+/**
+ * How many of `block`'s fields this flow has no editor for.
+ *
+ * The count that has to exist SOMEWHERE VISIBLE, because `configOptionDisabled`
+ * marks those rows and the HOST REMOVES THEM: `dialog-select.tsx`'s `filtered()`
+ * keeps `x.disabled !== true`, so a disabled row is never drawn, dimmed or
+ * otherwise. The alternative — rendering them as ordinary rows and refusing the
+ * choice in `configSelect` — would show a row that swallows Enter and does
+ * nothing, which is the dead-knob defect this flow is built to avoid. So the
+ * rows go, and the count goes on the block.
+ */
+function uneditableBlockCount(block: ConfigBlock): number {
+  return block.fields.filter(field => editorFor(field) === 'none').length
+}
+
+/**
+ * A boolean's value in words, with a glyph that is NOT the carrier.
+ *
+ * The house rule applied to a new place: colour is never the only signal, and
+ * neither is a bare glyph. `✅ enabled` survives a monochrome terminal, a narrow
+ * font and a font that has no glyph at all — the word is what remains — and the
+ * same two words are what the switch SCREEN spells out in full.
+ */
+function describeConfigToggle(value: boolean): string {
+  return value ? '✅ enabled' : '☐ disabled'
+}
+
+/**
+ * What a row shows at its RIGHT EDGE, which is where the CURRENT value lives.
+ *
+ * The counterpart to `configOptionDescription`, and the change a user actually
+ * sees. Values used to sit in the description, immediately after the label, so
+ * every row's value began at a different column and the eye had to read nine
+ * rows to compare two settings. The host renders `footer` right-aligned against
+ * a flexing title, so the same nine values now line up in a column of their own
+ * and the labels in another.
+ *
+ * EVERY DIRTY MARKER CARRIES A NUMBER as well as its glyph, where a count is
+ * meaningful. The `*` is a glyph: it survives colour loss, a narrow font and a
+ * monochrome terminal, but it does not say HOW MUCH, and "which block did I
+ * change" is a question a count answers and a star does not. A FIELD's count
+ * would be 1 by construction — the row is the change — so it gets the glyph
+ * alone; a BLOCK gets `N changed  *` because the block is where the ambiguity
+ * is.
+ *
+ * `undefined` for the rows that have no state to report: the scope, back, save
+ * and close rows say the same thing every time, and a right-aligned column of
+ * repeated sentences is a column nobody reads.
+ */
+export function configOptionFooter(
+  option: ConfigOption,
+  draft: ConfigDraft,
+  base: ConfigDraft
+): string | undefined {
+  switch (option.kind) {
+    case 'field': {
+      const current = configValueAt(draft, option.field.path)
+      // A boolean is the one value whose bare rendering is `true`/`false`, which
+      // names the type rather than the state. `✅ enabled` says what the setting
+      // is, and the glyph is the same one the switch row uses for the same two
+      // answers, so the two screens speak one vocabulary.
+      const value = option.field.kind === 'boolean'
+        ? describeConfigToggle(current === true)
+        : describeConfigValue(current)
+      // THIS ROW'S OWN dirtiness, and never the draft's. The adapter has a
+      // whole-draft `configIsDirty` boolean available and it is the WRONG input
+      // here — one bit about the entire config would mark every row in the list
+      // when one field is staged. A `*` on rows the user never touched is a mark
+      // that means "something changed somewhere", and the whole reason it moved
+      // into a right-aligned column is that it is a per-row signal.
+      return configFieldDirty(option.field, draft, base) ? `${value}  *` : value
+    }
+    case 'block': {
+      const count = option.block.fields.length
+      if (count === 0) return 'no settings'
+      const changed = configBlockDirtyCount(option.block, base, draft)
+      const settings = `${count} ${count === 1 ? 'setting' : 'settings'}`
+      return changed === 0 ? settings : `${settings}  ${changed} changed  *`
+    }
+    case 'scope':
+    case 'switch':
+    case 'back':
+    case 'save':
+    case 'close':
+      return undefined
+  }
+}
+
 /**
  * The line of help under a `prompt`'s title, or nothing.
  *
@@ -824,11 +974,20 @@ export function configPromptDescription(field: ConfigField): string | undefined
 /**
  * Whether the host should refuse this row.
  *
- * Only one case: a value this flow has no editor for. It is still LISTED —
- * omitting it would make a setting look non-existent rather than unchangeable,
- * which is the same defect as a dead knob — and the host's `disabled` flag
- * renders it and refuses it, which is a real host feature rather than a
- * hand-rolled grey row.
+ * Only one case: a value this flow has no editor for. It is still OFFERED — the
+ * flow hands it to the host as a `disabled` row rather than dropping it from
+ * `fieldOptions` — but the HOST REMOVES IT FROM THE LIST: `filtered()` keeps
+ * `x.disabled !== true`, and it does that before the filter input and before
+ * anything is drawn. So `true` here does not mean "drawn grey" and there is no
+ * `disabled`-looking marker to draw ourselves: the row is ABSENT.
+ *
+ * WHICH MEANS THE FACT HAS TO BE SAID ELSEWHERE, and it is said on the block
+ * row's description — see `uneditableBlockCount`. The alternative, rendering
+ * these as ordinary rows and refusing the selection in `configSelect`, would
+ * give the user a row that takes Enter and does nothing: the dead knob. And
+ * `configSelect` still returns `stay` for such a field, not because the host
+ * will let the row through but because nothing may become a write on a path no
+ * row chose.
  *
  * `save` IS NEVER DISABLED, and this is deliberate rather than an oversight, so
  * it is stated here where the temptation to "fix" it lives. Greying Save out when
@@ -854,14 +1013,26 @@ export function configOptionDisabled(option: ConfigOption): boolean {
  * `Plugin`, the solid provider and the hook — `DialogSelectOption` lives in
  * `dist/tui/context.d.ts` and is not part of the public entry, and the adapter
  * must not reach into `dist/` for it. This is a structural SUBSET of that
- * interface (title, value, description?, disabled?), so an array of these is
- * assignable to what `ui.dialog.select` asks for, and the check is the
- * compiler's rather than this comment's.
+ * interface (title, value, description?, footer?, category?, disabled?), so an
+ * array of these is assignable to what `ui.dialog.select` asks for, and the
+ * check is the compiler's rather than this comment's.
+ *
+ * THE FOUR SLOTS ARE NOT INTERCHANGEABLE, and the host is what makes them so.
+ * Reading `dialog-select.tsx`'s `Option`: `title` is the row, `description`
+ * renders MUTED AND INLINE immediately after it, `footer` renders MUTED AND
+ * RIGHT-ALIGNED after the flexible title, and `category` puts a BOLD ACCENT
+ * header above the row's group. So the routing decision this file now makes is
+ * title = what the row IS, description = the context that disambiguates it,
+ * footer = its current state, and the host lays them out. A value in a
+ * description reads as a parenthetical about the setting; the same value in a
+ * footer reads as a column, which is what it is.
  */
 export interface ConfigRow<Option> {
   readonly title: string
   readonly value: Option
   readonly description?: string
+  readonly footer?: string
+  readonly category?: string
   readonly disabled?: boolean
 }
 
@@ -873,18 +1044,6 @@ export type ConfigOption =
   | { readonly kind: 'block'; readonly block: ConfigBlock }
   /** One field. Choosing it opens that field's editor. */
   | { readonly kind: 'field'; readonly field: ConfigField }
-  /** The hub's search row. Choosing it asks the host for a query. */
-  | { readonly kind: 'search' }
-  /**
-   * A search that matched nothing, standing in for the result list.
-   *
-   * A ROW rather than an absence of one, and that is the whole reason it exists:
-   * `ui.dialog.select` with zero options is a dialog the user can see but not
-   * leave, and it looks exactly like a failed load. A row that names the query
-   * that missed and says what the search covers turns "nothing here" into
-   * something the user can read and something they can answer.
-   */
-  | { readonly kind: 'no-results'; readonly query: string }
   /**
    * The one answer a boolean editor offers: switch to the OTHER value.
    *
@@ -900,7 +1059,7 @@ export type ConfigOption =
   | { readonly kind: 'close' }
 
 /**
- * The hub's rows: the save scope, search, then every block, then save and close.
+ * The hub's rows: the save scope, then every block, then save and close.
  *
  * `save` and `close` are rows rather than the absence of a selection, because
  * "press escape to leave" and "press escape to throw your changes away" are the
@@ -908,12 +1067,12 @@ export type ConfigOption =
  * nothing staged to throw away in the first place, since nothing is written
  * until save.
  *
- * SEARCH IS THE SECOND ROW, and its position is load-bearing rather than
- * stylistic. The hub lists every config key, so it is past a screenful on any
- * real config; a search row below the blocks would sit under the fold on every
- * device this ships to, and a feature that is never seen is a feature with no
- * users. Immediately after the scope row is the only place in the list a user
- * reads before scrolling.
+ * THERE IS NO SEARCH ROW, and there was one here until last release. The host
+ * draws a fuzzy filter above every `select` it shows — over `title` and
+ * `category`, live, as the user types — so a row advertising a search was
+ * advertising something the user was already doing, and the screen it opened
+ * made them press Enter before the typing could start. Filtering this list needs
+ * no row of its own; see the note on `ConfigScreen`.
  */
 export function blockOptions(
   discovery: ConfigDiscovery,
@@ -921,13 +1080,67 @@ export function blockOptions(
 ): readonly ConfigOption[] {
   return [
     { kind: 'scope', scope },
-    { kind: 'search' as const },
     ...discovery.blocks.map(block => ({ kind: 'block' as const, block })),
     { kind: 'save' as const },
     { kind: 'close' as const }
   ]
 }
 
+/**
+ * THE HUB'S CURRENT ROW, which is the scope row, or `undefined` elsewhere.
+ *
+ * `current` is the host's own vocabulary for "of these, this is the one in
+ * effect", and it is used here for the one row on the one screen where the
+ * question has a single honest answer: the hub offers project and global as
+ * alternatives, and exactly one of them is where Save will write. The host draws
+ * a `●` in the row's gutter and tints it `theme.primary` — so this is a mark
+ * that is a glyph as well as a colour, which is what this flow's dirty markers
+ * are held to.
+ *
+ * SEMANTICS, verified in `dialog-select.tsx` rather than assumed, because the
+ * prop does one more thing than mark the row: an effect watches `props.current`
+ * and calls `setStore("selected", currentIndex)`, so it MOVES THE CURSOR there.
+ * On the hub that is harmless and arguably good — the scope row is row 0, which
+ * is where the cursor already is. It is stated here because the same call on
+ * the field list would be a defect: it would park the cursor on whichever field
+ * happened to be current and skip the first row, and a user who opens a block to
+ * change its FIRST setting would start on the wrong one. So this is a hub-only
+ * decision, stated as one.
+ *
+ * `undefined` on the other screens rather than a default: a row marked `current`
+ * that is not the one in effect is worse than no mark, and the editor's switch
+ * row is by construction the value the field is NOT on.
+ */
+export function configHubCurrent(options: readonly ConfigOption[]): ConfigOption | undefined {
+  return options.find(option => option.kind === 'scope')
+}
+
+/**
+ * ── ON `category` ──
+ *
+ * The host groups rows under a BOLD ACCENT header (`groupBy(x => x.category ??
+ * ""`, plus a blank line before every group after the first), and it is a real
+ * capability this flow does not use. That is a decision, and the reasoning is
+ * the point:
+ *
+ * The FIELD LIST IS PER BLOCK. Every row on it belongs to the one block named in
+ * the dialog's title, so one category is one group: a header reading `budget`
+ * above nine rows whose title is already `Nexus configuration — budget`. That is
+ * the redundant header this flow does not draw.
+ *
+ * The HUB is the other candidate, and grouping it by category would be worse than
+ * nothing for a specific reason: the hub's rows are ONE PER BLOCK, each already
+ * named by its own title. A category per block groups one row under a header
+ * that repeats its name, nine times. Grouping the hub's three NON-block rows
+ * (scope, save, close) under a header is the only version that would draw
+ * something true — and it would bury the save row under a heading, moving the
+ * row the whole flow exists to make findable further from the top of the list.
+ *
+ * So the value moves to the FOOTER and the grouping stays out. A capability is
+ * worth adopting where it says something the layout does not, and here on both
+ * screens the category would be a restatement of the title.
+ */
+
 /**
  * A block's rows: every field in it, then a way back.
  *
@@ -992,135 +1205,12 @@ export function configScreenOptions(
   current: (field: ConfigField) => unknown
 ): readonly ConfigOption[] {
   if (screen.kind === 'blocks') return blockOptions(discovery, scope)
-  if (screen.kind === 'search') return searchOptions(discovery, screen.query)
   if (screen.kind === 'fields') return fieldOptions(discovery, screen.block)
   return screen.field.kind === 'boolean'
     ? booleanOptions(screen.field, current(screen.field) === true)
     : []
 }
 
-// ── Searching the hub ───────────────────────────────────────────────
-
-/**
- * The search's text, or `undefined` when there is nothing to search for.
- *
- * A dismissed prompt and an empty one are the SAME query, which is the point:
- * both mean "no query", and both mean the flow stays where it was. Normalising
- * them at the boundary means no later function has to ask which of the two it
- * got, and an empty string can never reach `searchOptions` as a query that
- * matches every row — which is the one outcome that would turn "search" into a
- * second copy of the hub.
- */
-export function configSearchQuery(raw: string | undefined): string | undefined {
-  const trimmed = raw?.trim()
-  return trimmed === undefined || trimmed === '' ? undefined : trimmed
-}
-
-/**
- * Lowercase both sides, once per call site that needs it.
- *
- * Search is a substring test, not a prefix and not a token: a user who types
- * `cost` means `maxTotalCost`, and a prefix rule would have told them nothing
- * matched. No fuzzy matching either — an edit distance invites the wrong row at
- * the top of a list whose whole job is addressing a specific key, and a wrong
- * match here is a config value changed to something the user never read.
- */
-function normalized(value: string): string {
-  return value.toLowerCase()
-}
-
-/**
- * Whether `field` is what the user typed.
- *
- * The LABEL or the DOTTED PATH, and the path is not redundant: `enabled` exists
- * in eight blocks, so a search for `budget.enabled` is only meaningful against
- * the path, and matching labels alone would return eight rows for it. Deep
- * matching is also the reason this is worth having over "jump to the block" —
- * a user who remembers `maxTotalCost` and not which block it lives in should
- * not have to walk nine blocks to find it.
- */
-export function fieldMatches(field: ConfigField, query: string): boolean {
-  const needle = normalized(configSearchQuery(query) ?? '')
-  if (needle === '') return false
-  return (
-    normalized(field.label).includes(needle) ||
-    normalized(configPathLabel(field.path)).includes(needle)
-  )
-}
-
-/** Whether the block is what the user typed, OR holds something that is. */
-export function blockMatches(block: ConfigBlock, query: string): boolean {
-  const needle = normalized(configSearchQuery(query) ?? '')
-  if (needle === '') return false
-  if (normalized(block.name).includes(needle)) return true
-  return block.fields.some(field => fieldMatches(field, query))
-}
-
-/** The fields `query` names, in the discovery's own order. */
-export function filterConfigFields(
-  discovery: ConfigDiscovery,
-  query: string
-): readonly ConfigField[] {
-  return discovery.fields.filter(field => fieldMatches(field, query))
-}
-
-/** The blocks `query` names or that hold something it names. */
-export function filterConfigBlocks(
-  discovery: ConfigDiscovery,
-  query: string
-): readonly ConfigBlock[] {
-  return discovery.blocks.filter(block => blockMatches(block, query))
-}
-
-/**
- * The search's rows.
- *
- * FIELDS FIRST, and that ordering is the feature. A user who typed a setting
- * name wants that setting, and a result list that led with the block containing
- * it would make them press Enter a second time to reach what they already
- * named. Blocks follow for the case where someone searched for a block's name
- * instead of a field's.
- *
- * A block appears ONLY if none of its fields matched, so a query like `enabled`
- * does not list the same eight settings twice — once as fields and once under
- * eight headings. A duplicate result is not a cosmetic problem here: each one
- * opens a different path, and a list that offers the same key twice under two
- * descriptions is a list nobody can learn to read.
- *
- * The `no-results` row is a ROW, and it is selectable, and it goes to the hub.
- * A `select` handed zero options cannot be escaped by anything but the host's
- * own key — and it is visually identical to a screen that failed to load, so a
- * user who mistyped once would be looking at what looks like a bug. `back` is
- * present unconditionally, which is what makes the search screen escapable even
- * when it has results.
- */
-export function searchOptions(
-  discovery: ConfigDiscovery,
-  query: string
-): readonly ConfigOption[] {
-  // The empty query is the ONE case that gets its own shape, and the reason is
-  // the same one `configSearchQuery` exists for. The live path normalises at the
-  // boundary so this cannot be reached with `''` — but a function that is
-  // exported, and tested, on its own terms should not depend on every caller
-  // having remembered that. Without the guard, `''` matches no field and no
-  // block, so the user would be told "no results" while staring at a row that
-  // quotes the empty string: a dead end manufactured out of a question that was
-  // never asked. `[{ kind: 'back' }]` is the honest answer — there is nothing to
-  // show and the screen stays escapable.
-  if (configSearchQuery(query) === undefined) return [{ kind: 'back' }]
-  const fields = filterConfigFields(discovery, query)
-  const blocks = filterConfigBlocks(discovery, query).filter(
-    block => !block.fields.some(field => fieldMatches(field, query))
-  )
-  const rows: ConfigOption[] = [
-    ...fields.map(field => ({ kind: 'field' as const, field })),
-    ...blocks.map(block => ({ kind: 'block' as const, block }))
-  ]
-  if (rows.length === 0) rows.push({ kind: 'no-results', query })
-  rows.push({ kind: 'back' })
-  return rows
-}
-
 // ── Navigation ──────────────────────────────────────────────────────
 
 /**
@@ -1141,18 +1231,6 @@ export type ConfigSelect =
   | { readonly kind: 'stay' }
   | { readonly kind: 'save' }
   | { readonly kind: 'close' }
-  /**
-   * The host has to produce a string before there is a screen to go to.
-   *
-   * Its own outcome rather than a `to`, and the reason is that the flow must not
-   * invent a state it has not decided to be in: `screen: {kind:'search'}` needs
-   * a `query`, and the only source of one is the host's prompt. Returning `to`
-   * with an empty query would make an EMPTY SEARCH a real screen — one that
-   * matched everything — so a dismissed prompt would silently drop the user into
-   * a list of every setting in the config. The adapter turns `ask` into the
-   * prompt, and stays put if there is no answer.
-   */
-  | { readonly kind: 'ask'; readonly screen: ConfigScreen }
 
 /**
  * Act on a chosen row.
@@ -1193,17 +1271,6 @@ export function configSelect(screen: ConfigScreen, option: ConfigOption): Config
       // is an ANSWER, not a destination: the flow does not move, and the adapter
       // commits it with `commitConfigToggle` and returns to the field's list.
       return { kind: 'stay' }
-    case 'search':
-      // An ASK, not a `to`. The `search` screen carries a query, and the query
-      // does not exist until the host's prompt produces one — so naming a screen
-      // here would mean naming one whose contents the flow has not decided.
-      // See `ConfigSelect`'s `ask`.
-      return { kind: 'ask', screen: { kind: 'search', query: '' } }
-    case 'no-results':
-      // Somewhere REAL rather than nowhere: a select with no options is
-      // unescapable and looks like a failed load. The hub is the one place a user
-      // can see every block, so it is where a dead end is worth routing to.
-      return { kind: 'to', screen: { kind: 'blocks' } }
     case 'back': {
       const up = configUp(screen)
       // Unreachable from any list the flow builds — `back` is only ever offered
@@ -1237,24 +1304,15 @@ export function configScreenField(screen: ConfigScreen): ConfigField | undefined
  */
 export function configUp(screen: ConfigScreen): ConfigScreen | undefined {
   if (screen.kind === 'blocks') return undefined
-  // ONE HOP, not a chain through the hub. The real path out of a search result
-  // is search → fields:<block> → blocks, and this is its penultimate step: an
-  // editor reached FROM a search goes to its block's field list, exactly as an
-  // editor reached from that list does, and the search screen itself goes
-  // straight to the hub. So the deepest route out of the flow is one escape
-  // from the editor, one from the field list, one from the hub — and a search
-  // screen that had to route through the hub first would put the user's
-  // "get me back to where I was" behind an extra list they did not ask for.
+  // ONE HOP, not a chain through the hub: the editor goes to its own block's
+  // field list rather than back past it, so the deepest route out of the flow
+  // is one escape from the editor, one from the field list, one from the hub.
   //
   // WHAT THIS RELIES ON: the editor screen is MODAL. `runEditor` awaits the
   // host's prompt and returns the answer, so the transient editor is not itself
   // an escape the user has to find — if a future refactor makes the editor a
   // screen the user navigates away from with the same key, the bound changes
   // and the counting above is no longer the guarantee.
-  //
-  // The query is not carried through, and does not need to be: escaping the
-  // search discards it, which is the same thing the user did by leaving.
-  if (screen.kind === 'search') return { kind: 'blocks' }
   if (screen.kind === 'fields') return { kind: 'blocks' }
   return { kind: 'fields', block: screen.field.block }
 }
@@ -1263,10 +1321,6 @@ export function configUp(screen: ConfigScreen): ConfigScreen | undefined {
 export function configScreenBlock(screen: ConfigScreen): string | undefined {
   switch (screen.kind) {
     case 'blocks':
-    // A search spans the whole config, so there is no single block it is in —
-    // and answering "which block" with the first one that matched would put the
-    // dialog's title on a block the user never entered.
-    case 'search':
       return undefined
     case 'fields':
       return screen.block
@@ -1304,9 +1358,9 @@ export function configFieldsScreen(field: ConfigField): ConfigScreen {
  * change. With one row standing only for the other value, that confusion is not
  * expressible: the row says what it writes, and this writes what the row says.
  *
- * The guard is on the ROW's kind and not on the value's type, so a `back` row, a
- * `save` row or a search result that reached here by mistake is refused rather
- * than written to a path nothing chose.
+ * The guard is on the ROW's kind and not on the value's type, so a `back` row or
+ * a `save` row that reached here by mistake is refused rather than written to a
+ * path nothing chose.
  */
 export function commitConfigToggle(field: ConfigField, chosen: ConfigOption): ConfigCommit {
   if (chosen.kind !== 'switch') {
diff --git a/src/tui.tsx b/src/tui.tsx
index 40889fa..f47f8c3 100644
--- a/src/tui.tsx
+++ b/src/tui.tsx
@@ -15,7 +15,8 @@ import {
   configPromptDescription,
   configSaveUpdate,
   configScreenTitle,
-  configSearchQuery,
+  configHubCurrent,
+  configOptionFooter,
   configScreenOptions,
   configSelect,
   configUp,
@@ -1288,19 +1289,35 @@ export default Plugin.define({
        */
       const changes = (): number => configDirtyCount(discovery, base, draft)
 
-      /** The row for one option. The row's VALUE is the option itself. */
-      const toDialogRow = (option: ConfigOption): ConfigRow<ConfigOption> => ({
-        title: configOptionTitle(option, configSaveScope),
-        description: configOptionDescription(
+      /**
+       * The row for one option. The row's VALUE is the option itself.
+       *
+       * The four text slots are routed by `config-flow.ts`, not here: title from
+       * `configOptionTitle`, the inline context from `configOptionDescription`,
+       * and the right-aligned current state from `configOptionFooter`. The
+       * `undefined`s are spread rather than assigned so an absent description or
+       * footer stays absent instead of rendering as the string "undefined".
+       */
+      const toDialogRow = (option: ConfigOption): ConfigRow<ConfigOption> => {
+        const description = configOptionDescription(
           option,
           draft,
           base,
           configIsDirty(base, draft),
           changes()
-        ),
-        value: option,
-        ...(configOptionDisabled(option) ? { disabled: true } : {})
-      })
+        )
+        // No `configIsDirty(base, draft)` here, and that omission is the point:
+        // the footer marks THIS row, and the draft-wide flag would mark every
+        // row in the list when one field was staged. See `configOptionFooter`.
+        const footer = configOptionFooter(option, draft, base)
+        return {
+          title: configOptionTitle(option, configSaveScope),
+          value: option,
+          ...(description === undefined ? {} : { description }),
+          ...(footer === undefined ? {} : { footer }),
+          ...(configOptionDisabled(option) ? { disabled: true } : {})
+        }
+      }
 
       /** Confirm a staged edit, saying plainly that nothing is on disk yet. */
       const noteStaged = (field: ConfigField, value: unknown) => {
@@ -1399,7 +1416,26 @@ export default Plugin.define({
         // `configUp` decides where it lands. There is no second commit path
         // through this function, which is what keeps "typed" and "saved" from
         // racing — the only way a value reaches the draft is `stage`.
-        const chosen = await context.ui.dialog.select({ title, options: options.map(toDialogRow) })
+        // `current` is the HOST's mark for the row that is already in effect, and
+        // the host draws a `●` in its gutter. Only the hub has one — the scope row
+        // — and `configHubCurrent` returns `undefined` on the other two screens,
+        // so the field list's cursor is never moved by it.
+        //
+        // `placeholder` is the search field's own hint text, and it IS settable
+        // per-screen (the plugin type has it), so the host's filter is told what
+        // it matches: the block and setting names it will actually look at.
+        const current = configHubCurrent(options)
+        const chosen = await context.ui.dialog.select({
+          title,
+          options: options.map(toDialogRow),
+          ...(current === undefined ? {} : { current }),
+          // A hint for the host's own filter, and only where there is a list long
+          // enough to want one: the two screens that list rows. The boolean
+          // switch screen has two rows and needs no filter.
+          ...(screen.kind === 'blocks' || screen.kind === 'fields'
+            ? { placeholder: 'Filter by name' }
+            : {})
+        })
 
         if (chosen === undefined) {
           const up = configUp(screen)
@@ -1425,21 +1461,6 @@ export default Plugin.define({
               stage(commitConfigToggle(chosen.field, chosen))
             }
             break
-          case 'ask': {
-            // The hub's search row. The flow named a screen but no query — the
-            // only source of a query is this prompt — so a dismissal or an empty
-            // line leaves the user exactly where they were rather than dropping
-            // them into a search that matched every setting in the config.
-            const typed = await context.ui.dialog.prompt({
-              title: 'Search settings',
-              description: 'Block names and setting names',
-              placeholder: 'e.g. maxTotalCost, or budget'
-            })
-            const query = configSearchQuery(typed)
-            if (query === undefined) break
-            screen = { kind: 'search', query }
-            break
-          }
           case 'to':
             screen =
               outcome.screen.kind === 'editor'
diff --git a/test/tui-config-flow.test.ts b/test/tui-config-flow.test.ts
index 66d552a..0207c46 100644
--- a/test/tui-config-flow.test.ts
+++ b/test/tui-config-flow.test.ts
@@ -15,7 +15,6 @@ mock.module('node:os', () => ({ ...realOs, default: realOs, homedir: () => SANDB
 
 const { NexusConfigManager } = await import('../src/config')
 const {
-  blockMatches,
   blockOptions,
   booleanOptions,
   commitConfigModel,
@@ -23,29 +22,28 @@ const {
   commitConfigToggle,
   configBlockDirtyCount,
   configDirtyCount,
+  configFieldContext,
+  configFieldDirty,
   configFieldsScreen,
+  configHubCurrent,
   configIsDirty,
   configOptionDescription,
   configOptionDisabled,
+  configOptionFooter,
   configOptionTitle,
   configPathLabel,
   configPromptDescription,
   configSaveUpdate,
   configScreenOptions,
   configScreenTitle,
-  configSearchQuery,
   configSelect,
   configUp,
   configValueAt,
   describeConfigValue,
   discoverConfig,
   editorFor,
-  fieldMatches,
   fieldOptions,
-  filterConfigBlocks,
-  filterConfigFields,
   parseConfigNumber,
-  searchOptions,
   setConfigValue
 } = await import('../src/config-flow')
 
@@ -126,18 +124,9 @@ function reachableScreens(
   const key = (screen: ConfigScreen): string =>
     screen.kind === 'blocks'
       ? 'blocks'
-      // The query is part of the ID, and it has to be: two different queries are
-      // two different screens with two different result lists, and keying on the
-      // kind alone would collide them in `seen` — the search would then be
-      // explored ONCE with whichever query the walk happened to try first, and
-      // the state-space count below would be quietly too small. That is a silent
-      // under-exploration: the walk returns a smaller `seen` and every assertion
-      // about it still passes.
-      : screen.kind === 'search'
-        ? `search:${screen.query}`
-        : screen.kind === 'fields'
-          ? `fields:${screen.block}`
-          : `editor:${screen.field.path.join('.')}`
+      : screen.kind === 'fields'
+        ? `fields:${screen.block}`
+        : `editor:${screen.field.path.join('.')}`
 
   const seen = new Map<string, ConfigScreen>([[key(initial), initial]])
   const queue: ConfigScreen[] = [initial]
@@ -429,19 +418,12 @@ describe('config flow reachability', () => {
     const discovery = discoverConfig(config)
     const reached = reachableScreens({ kind: 'blocks' }, discovery, config, 'global')
 
-    // SEARCH IS NOT REACHABLE BY THE WALK, stated directly so the guarantee is
-    // not resting on a count. A `search` screen's `query` does not exist until the
-    // host's prompt produces one, and the hub's search row yields `ask` rather than
-    // `to` precisely so the flow cannot navigate to a screen with a query it never
-    // got. This is the assertion that pins it.
-    expect(reached.some(screen => screen.kind === 'search')).toBe(false)
-    // The walk covers the WHOLE rest of the state space. One hub, one list per
-    // block, one editor per field — derived from the discovery rather than written
-    // down, so a block or a field that produced no screen at all fails here
-    // instead of quietly shrinking the search. The `+1` the search screen would
-    // add is absent, which is the count-level echo of the assertion above: a
-    // change that made `ask` a `to` — the fix that would let a blank prompt drop a
-    // user into a list of the whole config — also breaks this number.
+    // The walk covers the WHOLE state space. One hub, one list per block, one
+    // editor per field — derived from the discovery rather than written down, so a
+    // block or a field that produced no screen at all fails here instead of
+    // quietly shrinking the search. This number is the search screen's tombstone:
+    // there is no `+1` for it any more, so reintroducing a fourth screen kind
+    // would break this count before anything softer noticed.
     expect(reached).toHaveLength(1 + discovery.blocks.length + discovery.fields.length)
 
     for (const screen of reached) {
@@ -649,11 +631,11 @@ describe('a boolean, as one switch and a way out', () => {
   it('refuses an answer that is not one of its own rows', () => {
     // The switch is the only thing a boolean editor can return, and a commit
     // that accepted anything else would be a write to a path nothing chose.
-    // Every hub row is tried, not just `back`: the search and no-results rows
-    // are the ones a later change could plausibly have let through here.
-    for (const kind of ['back', 'save', 'search', 'no-results'] as const) {
-      const option =
-        kind === 'no-results' ? ({ kind, query: 'x' } as const) : ({ kind } as const)
+    // Every non-switch row is tried, not just `back`, because a row that is not
+    // a switch reaching here at all is the defect — whatever a later change adds
+    // to the hub has to be refused here too.
+    for (const kind of ['back', 'save', 'close', 'scope'] as const) {
+      const option = { kind, scope: 'project' } as const
       expect(() => commitConfigToggle(field, option as never)).toThrow(/switch row/)
     }
   })
@@ -784,7 +766,7 @@ describe('the models block still routes through the grouped picker', () => {
 // ── Rows carry the current value and a staged-change mark ───────────
 
 describe('config flow rows', () => {
-  it('shows every field row\'s current value, and marks the ones that differ from disk', () => {
+  it('shows every field row\'s current value in the FOOTER, and its description is not the value', () => {
     const config = realConfig()
     const discovery = discoverConfig(config)
     const field = fieldAt(discovery, 'budget.maxTotalCost')
@@ -793,16 +775,99 @@ describe('config flow rows', () => {
     // `base` is the third argument and is REQUIRED, which is the point: an
     // omitted one defaulted to `draft` would report "0 changed" on every row
     // rather than failing to compile.
-    expect(configOptionDescription(row as never, config, config, false)).toBe('10')
+    //
+    // THE ROUTING IS THE CLAIM, and it is asserted per-field on the real config
+    // rather than by a substring sweep over the row. The host renders `footer`
+    // right-aligned and `description` muted and inline, so where the value goes
+    // decides whether the field list reads as two aligned columns or as nine
+    // sentences. `expect(description).not.toContain('10')` alone would be weak —
+    // a row with the value in BOTH slots passes it — so the description is
+    // asserted to be ABSENT here, which is what it is: a field directly under
+    // its block has a label that is already its whole address.
+    expect(configOptionFooter(row as never, config, config)).toBe('10')
+    expect(configOptionDescription(row as never, config, config, false)).toBeUndefined()
 
     // The staged value shows immediately, marked, because the only other place it
-    // appears is a toast that has already gone. The `25  *` string is UNCHANGED
-    // by the dirty-count work — a field row gets no number, because 0 and 1 are
-    // not information and `25  *  1 changed` is noise.
+    // appears is a toast that has already gone. A field row gets no NUMBER with
+    // its `*`, because 1 is not information and `25  *  1 changed` is noise.
     const staged = setConfigValue(config, field.path, 25)
-    expect(configOptionDescription(row as never, staged, config, true)).toBe('25  *')
-    // …and an UNSTAGED value is not marked, so a `*` always means "not on disk".
-    expect(configOptionDescription(row as never, staged, config, false)).toBe('25')
+    expect(configOptionFooter(row as never, staged, config)).toBe('25  *')
+    // …and a `*` always means "not on disk", checked on a field that was NOT
+    // staged. Dirtiness is per field now (`configFieldDirty`), so the honest
+    // unmarked case is a sibling row rather than this one with a flag turned off.
+    const sibling = fieldOptions(discovery, 'budget').find(
+      o => o.kind === 'field' && o.field.label === 'maxCostPerTask'
+    ) as never
+    expect(configOptionFooter(sibling, staged, config)).toBe('1')
+  })
+
+  it('gives a NESTED field its path as the description, so two identically named fields are tellable apart', () => {
+    // The reason `description` is not free for values. Every element of
+    // `customRoles` is labelled by the key it sits under, so `model` appears once
+    // per role and a list of identical rows is a list nobody can pick from. The
+    // host fuzzy-filters `category` as well as `title` (1:2), but `title` is what
+    // is drawn, so the disambiguation has to be drawn too.
+    const discovery = realDiscovery()
+    const withRoles = discoverConfig({
+      customRoles: [
+        { name: 'architect', model: 'anthropic/claude-sonnet-4-6' },
+        { name: 'tester', model: 'openai/gpt-5-mini' }
+      ]
+    })
+    const models = withRoles.fields.filter(f => f.label === 'model')
+    expect(models).toHaveLength(2)
+    // Same label, same kind, DIFFERENT description — and the different
+    // description is the whole point.
+    expect(configOptionTitle({ kind: 'field', field: models[0] }, 'global')).toBe('model')
+    expect(configOptionTitle({ kind: 'field', field: models[1] }, 'global')).toBe('model')
+    const first = configOptionDescription({ kind: 'field', field: models[0] } as never, {}, {}, false)
+    const second = configOptionDescription({ kind: 'field', field: models[1] } as never, {}, {}, false)
+    // WITHOUT the block name: the list's title is already
+    // `Nexus configuration — customRoles`, so repeating it on every row is ink
+    // that says nothing. `[0]` and `[1]` are the part that is not already on
+    // screen, and they are the whole disambiguation.
+    expect(first).toBe('[0].model')
+    expect(second).toBe('[1].model')
+    expect(first).not.toBe(second)
+
+    // And the VALUE is still in the footer on a nested field, not promoted into
+    // the description to pay for the path.
+    const draft: ConfigDraft = {
+      customRoles: [
+        { name: 'architect', model: 'anthropic/claude-sonnet-4-6' },
+        { name: 'tester', model: 'openai/gpt-5-mini' }
+      ]
+    }
+    expect(
+      configOptionFooter({ kind: 'field', field: models[1] } as never, draft, draft)
+    ).toBe('openai/gpt-5-mini')
+    // A field directly under its block gets NO description, because the path
+    // minus the block prefix is the label and the title is already the block.
+    expect(configFieldContext(fieldAt(discovery, 'budget.maxTotalCost'))).toBeUndefined()
+  })
+
+  it('says a BOOLEAN\'s state in words and a glyph in the footer, never as a bare true/false', () => {
+    // `true` names the TYPE, not the state, and this flow's rule is that no
+    // signal is carried by colour or by a glyph alone. The footer must read the
+    // same way the switch SCREEN reads, so the two screens speak one vocabulary.
+    const config = realConfig()
+    const discovery = discoverConfig(config)
+    const row = fieldOptions(discovery, 'gitFlow').find(o => o.kind === 'field') as never
+    const field = (row as { field: ConfigField }).field
+    expect(field.kind).toBe('boolean')
+
+    const on = configOptionFooter(row, config, config)
+    expect(on).toMatch(/^(✅|☐) (enabled|disabled)$/)
+    // A boolean in the FIELD LIST, not just on the switch screen: the glyph is
+    // never the carrier, and `true` alone names the type rather than the state.
+    // Flipped: the other word, and still a word.
+    const flipped = setConfigValue(config, field.path, false)
+    const off = configOptionFooter(row, flipped, config)
+    expect(off).toMatch(/^(✅|☐) disabled {2}\*$/)
+    expect(off).not.toBe(on)
+    // Never the bare literal, in either direction.
+    expect(on).not.toBe('true')
+    expect(off).not.toBe('false')
   })
 
   it('says plainly that nothing is written until Save, on the two rows that decide it', () => {
@@ -836,7 +901,8 @@ describe('config flow rows', () => {
     expect(configPromptDescription(fieldAt(discovery, 'models.coder'))).toBeUndefined()
   })
 
-  it('counts a block\'s settings, and says so when a block has none', () => {    // `customRoles` is `[]` on a fresh install, and a row reading "0 settings"
+  it('counts a block\'s settings in the FOOTER, and says so when a block has none', () => {
+    // `customRoles` is `[]` on a fresh install, and a row reading "0 settings"
     // with nothing behind it is indistinguishable from a block the flow failed to
     // load.
     const discovery = realDiscovery()
@@ -844,15 +910,148 @@ describe('config flow rows', () => {
       o => o.kind === 'block' && o.block.name === 'customRoles'
     )
     const config = realConfig()
+    // The count is a FOOTER, like every other current value — a block's size is
+    // its state, and putting it in the description would make the hub the one
+    // screen whose numbers do not line up.
+    expect(configOptionFooter(customRoles as never, config, config)).toBe('no settings')
     expect(configOptionDescription(customRoles as never, config, config, false)).toMatch(/no settings here yet/)
 
     const budget = blockOptions(discovery, 'global').find(o => o.kind === 'block' && o.block.name === 'budget')
     // A SHAPE, not a count. The exact number is a fact about `budget` and would
     // fail for a reason no user would recognise when a key is added; what matters
     // is that a block with fields counts them and a block with none says so.
-    // UNCHANGED by the dirty badge: a CLEAN block's description is still exactly
+    // UNCHANGED by the dirty badge: a CLEAN block's footer is still exactly
     // `N settings`, so this regex has to keep passing verbatim.
-    expect(configOptionDescription(budget as never, config, config, false)).toMatch(/^\d+ settings$/)
+    expect(configOptionFooter(budget as never, config, config)).toMatch(/^\d+ settings$/)
+    // AND, the other direction of the claim: a block whose footer carries the
+    // count has no description at all, rather than one repeating the count. This
+    // is the assertion that fails if someone routes the count back to the
+    // description "for consistency with the old layout".
+    expect(configOptionDescription(budget as never, config, config, false)).toBeUndefined()
+  })
+
+  it('marks only the field that moved, not every row in the block', () => {
+    // THE `*` IS A PER-ROW SIGNAL, and this is the assertion that says so. It
+    // used to be driven by the adapter's whole-draft `configIsDirty` boolean, so
+    // staging `maxTotalCost` marked `maxCostPerTask` and `alertThreshold` too —
+    // a `*` on rows nobody touched is a mark meaning "something changed
+    // somewhere", and a user who cannot trust it cannot use it to find their own
+    // edit. It is worse in a footer than it was in a description, because a
+    // right-aligned column of markers is exactly what a user scans to find what
+    // they changed.
+    const config = realConfig()
+    const discovery = realDiscovery()
+    const rows = fieldOptions(discovery, 'budget').filter(o => o.kind === 'field') as never[]
+    const staged = setConfigValue(config, ['budget', 'maxTotalCost'], 25)
+
+    const marked = rows.map(row => configOptionFooter(row, staged, config))
+    expect(marked.filter(text => text?.includes('*'))).toHaveLength(1)
+    expect(marked[0]).toBe('25  *')
+    // The two untouched rows show their values and no marker, which is the
+    // assertion that fails if the draft-wide flag is ever wired back in.
+    expect(marked[1]).not.toContain('*')
+    expect(marked[2]).not.toContain('*')
+    // And the exported predicate agrees, so the rule is testable on its own
+    // rather than only through a rendered string.
+    const field = fieldAt(discovery, 'budget.maxTotalCost')
+    expect(configFieldDirty(field, config, staged)).toBe(true)
+    expect(configFieldDirty(field, config, config)).toBe(false)
+    expect(configFieldDirty(fieldAt(discovery, 'budget.maxCostPerTask'), config, staged)).toBe(false)
+  })
+
+  it('leaves the hub\'s own rows with a description and NO footer, so one rule covers them all', () => {
+    // The consistency claim, stated: `footer` is the CURRENT-STATE column, and
+    // scope/save/close/back have no state to report — they say the same thing
+    // every time they are drawn. A right-aligned column of repeated sentences is a
+    // column nobody reads, so they get a description and an absent footer.
+    const config = realConfig()
+    const discovery = realDiscovery()
+    const hub = blockOptions(discovery, 'global')
+    for (const kind of ['scope', 'save', 'close'] as const) {
+      const row = hub.find(o => o.kind === kind) as never
+      expect(configOptionFooter(row, config, config)).toBeUndefined()
+      expect(configOptionDescription(row, config, config, true)).toBeTypeOf('string')
+    }
+    // …and the boolean switch screen, whose two rows are answers rather than
+    // settings, is the same case: no state column, all context inline.
+    const enabled = fieldAt(discovery, 'gitFlow.enabled')
+    const switchRow = booleanOptions(enabled, false)[0]
+    expect(configOptionFooter(switchRow, config, config)).toBeUndefined()
+    expect(configOptionDescription(switchRow, config, config, false)).toMatch(/Turns it on/)
+  })
+
+  it('marks the hub\'s scope row as the CURRENT one, and no other screen has a current row', () => {
+    // `current` is the host's own vocabulary for "of these, this is the one in
+    // effect" — it draws a `●` in the row's gutter and tints it `theme.primary`.
+    // The scope row is exactly that question with one honest answer: Save writes
+    // to project or to global, and only one of them.
+    const discovery = realDiscovery()
+    const hub = blockOptions(discovery, 'project')
+    const current = configHubCurrent(hub)
+    expect(current?.kind).toBe('scope')
+    // It is the row the scope ASKED for, so the mark follows the toggle rather
+    // than sitting on a fixed row.
+    expect(configHubCurrent(blockOptions(discovery, 'global'))).toEqual(
+      blockOptions(discovery, 'global').find(o => o.kind === 'scope')
+    )
+    // HUB ONLY, and the reason is in `configHubCurrent`: the host also MOVES the
+    // cursor to the current row, so on a field list it would park the cursor on
+    // whichever field happened to be current and skip the first one.
+    for (const block of discovery.blocks) {
+      expect(configHubCurrent(fieldOptions(discovery, block.name))).toBeUndefined()
+    }
+    const enabled = fieldAt(discovery, 'gitFlow.enabled')
+    expect(configHubCurrent(booleanOptions(enabled, false))).toBeUndefined()
+  })
+})
+
+// ── Uneditable fields are hidden by the host, so the BLOCK says so ──
+
+describe('a setting the host will not draw is still said to exist', () => {
+  // THE HOST FILTERS `disabled` ROWS OUT. `dialog-select.tsx`'s `filtered()` is
+  // `filter(x => x.disabled !== true)` before anything is drawn, so `disabled:
+  // true` is not a dimmed row and there is no marker to draw — the row is ABSENT.
+  // Which means `configOptionDisabled` on its own is a silent deletion, and the
+  // count has to be said on the block row that survives.
+  const config: ConfigDraft = { odd: { ok: true, when: null } }
+  const discovery = discoverConfig(config)
+  const blockRow = blockOptions(discovery, 'global').find(
+    o => o.kind === 'block' && o.block.name === 'odd'
+  ) as never
+
+  it('still offers the field as a row, marked disabled', () => {
+    const when = fieldAt(discovery, 'odd.when')
+    const row = fieldOptions(discovery, 'odd').find(
+      o => o.kind === 'field' && o.field === when
+    )
+    // The flow does not DROP it: the row is built, and `disabled` is how it is
+    // refused. A field that vanished from `fieldOptions` would be a setting the
+    // flow believes it cannot address at all, which is a different and larger lie.
+    expect(row).toBeDefined()
+    expect(configOptionDisabled(row as never)).toBe(true)
+    // And it is still not somewhere the flow can go.
+    expect(configSelect(configFieldsScreen(when), row as never)).toEqual({ kind: 'stay' })
+  })
+
+  it('counts it in the BLOCK\'s description, so the block does not over-claim', () => {
+    // The claim that would fail if the counting were left out: the footer says
+    // "2 settings" and the block genuinely holds 2 — but only 1 of them will be
+    // on screen, and the difference between what the row says and what the user
+    // sees is exactly the silent-vanishing defect.
+    expect(configOptionFooter(blockRow, config, config)).toBe('2 settings')
+    expect(configOptionDescription(blockRow, config, config, false)).toBe(
+      '1 setting not editable here'
+    )
+  })
+
+  it('says nothing at all for a block whose every field is editable', () => {
+    // The counterpart, so the sentence cannot become boilerplate: it is a fact
+    // about THIS block, not a line every row carries.
+    const real = realDiscovery()
+    const budget = blockOptions(real, 'global').find(
+      o => o.kind === 'block' && o.block.name === 'budget'
+    ) as never
+    expect(configOptionDescription(budget, realConfig(), realConfig(), false)).toBeUndefined()
   })
 })
 
@@ -998,193 +1197,6 @@ describe('config flow save path', () => {
   })
 })
 
-// ── Search ──────────────────────────────────────────────────────────
-//
-// Search is ONE-SHOT, and that is a property of the host rather than a choice:
-// `ui.dialog.select` owns the lifetime of its list and exposes no `onInput`, so
-// a persistent filter field would have to keep the query in the ADAPTER, where
-// no test can drive it and where a decision would live that this file does not
-// own. A prompt, then a list, keeps the query in a `ConfigScreen` the flow
-// decided — so `searchOptions` is headlessly testable at all, which is the only
-// reason this can be tested rather than hoped for.
-
-describe('config flow search', () => {
-  const config = realConfig()
-  const discovery = discoverConfig(config)
-
-  it('treats an empty or absent prompt as no search, so a blank query is never a query', () => {
-    // The load-bearing one. An empty string reaching `searchOptions` would match
-    // every row — turning "search" into a second copy of the hub, reachable by
-    // pressing Enter on an empty prompt.
-    for (const raw of ['', '   ', '\t', undefined]) {
-      expect(configSearchQuery(raw)).toBeUndefined()
-    }
-    // Trimmed, not merely tested for emptiness: a query with a stray leading
-    // space should match the same rows as one without.
-    expect(configSearchQuery('  budget  ')).toBe('budget')
-    // And the same rule reaches the matchers, so a blank query matches nothing
-    // rather than everything.
-    const field = fieldAt(discovery, 'budget.maxTotalCost')
-    expect(fieldMatches(field, '')).toBe(false)
-  })
-
-  it('matches a field by its label OR its dotted path, case-insensitively, as a substring', () => {
-    const cost = fieldAt(discovery, 'budget.maxTotalCost')
-    // By label…
-    expect(fieldMatches(cost, 'maxTotalCost')).toBe(true)
-    // …by path, which is not redundant: `enabled` exists in eight blocks, so a
-    // qualified search is the only one that can identify a single setting.
-    expect(fieldMatches(cost, 'budget.maxTotal')).toBe(true)
-    // Case is folded on BOTH sides, and it is a SUBSTRING rather than a prefix:
-    // a user who types `cost` means `maxTotalCost`.
-    expect(fieldMatches(cost, 'MAXtotalcost')).toBe(true)
-    expect(fieldMatches(cost, 'cost')).toBe(true)
-    // And something that is not there is not there. No fuzzy matching: a wrong
-    // row at the top of a list whose job is addressing one key is a config value
-    // changed to something the user never read.
-    expect(fieldMatches(cost, 'costt')).toBe(false)
-    expect(fieldMatches(cost, 'gateway')).toBe(false)
-  })
-
-  it('matches a block by its own name OR by any field it holds', () => {
-    const budget = discovery.blocks.find(block => block.name === 'budget')
-    if (budget === undefined) throw new Error('no budget block')
-    expect(blockMatches(budget, 'budget')).toBe(true)
-    // A field's name is enough to find its block, which is the "I remember the
-    // setting but not where it lives" case search exists for.
-    expect(blockMatches(budget, 'maxTotalCost')).toBe(true)
-    expect(blockMatches(budget, 'gateway')).toBe(false)
-    // Case-insensitivity is `blockMatches`' OWN fold, and the field tests do not
-    // reach it: a block is matched by its NAME as well as by its fields, so the
-    // name fold has to hold separately or a block search is case-sensitive while
-    // a field search is not — the same word, two answers, depending on where the
-    // user looked for it.
-    expect(blockMatches(budget, 'BUDGET')).toBe(true)
-    expect(blockMatches(budget, 'BuDgEt')).toBe(true)
-  })
-
-  it('answers an empty search with `back` alone, not a row quoting nothing', () => {
-    // `searchOptions` is exported and tested on its own terms, so it cannot rely
-    // on every caller having normalised at the boundary. The live path does
-    // (`configSearchQuery`, and the adapter before it), but a function called
-    // directly with `''` would otherwise match nothing and report "no results"
-    // while quoting the empty string: a dead end manufactured out of a question
-    // nobody asked.
-    for (const empty of ['', '   ', '\t\n ']) {
-      expect(searchOptions(discovery, empty)).toEqual([{ kind: 'back' }])
-    }
-  })
-
-  it('leads with the matching FIELD, and lists a block only if none of its fields matched', () => {
-    const cost = fieldAt(discovery, 'budget.maxTotalCost')
-    const rows = searchOptions(discovery, 'maxTotalCost')
-    const budgetBlock = discovery.blocks.find(block => block.name === 'budget') as never
-
-    // The FIELD is first, and this ordering is the feature: the result opens the
-    // setting's editor directly, with no second Enter to descend through the
-    // block. Searching for a block name is the case that still needs the hop.
-    expect(rows[0]).toEqual({ kind: 'field', field: cost })
-    // `budget` matched (it holds `maxTotalCost`) but is NOT listed as a block
-    // row: the same setting appearing twice under two descriptions is a list
-    // nobody can learn to read.
-    expect(rows.some(row => row.kind === 'block' && (row.block as { name: string }).name === 'budget')).toBe(false)
-    expect(rows).not.toContainEqual(budgetBlock)
-    // Exactly one way out, always.
-    expect(rows.filter(row => row.kind === 'back')).toHaveLength(1)
-  })
-
-  it('lists a block as a block only when none of its fields matched', () => {
-    // The no-double-listing rule needs a block whose fields do NOT match, and in
-    // the real config no such block exists for a real query: every field's PATH
-    // carries the block's name, so a query naming a block matches all of that
-    // block's fields and the block is correctly suppressed in favour of the
-    // fields. So this is pinned on a fixture built for the case rather than
-    // wished for on the real config — a `gateway` block whose fields are called
-    // `enabled` and `port`, exactly the shape that makes the two rules differ.
-    const gateway = discoverConfig({ gateway: { enabled: true, port: 1 } })
-    const rows = searchOptions(gateway, 'gateway')
-
-    // `gateway.enabled`'s PATH contains "gateway", so it matches and leads…
-    expect(rows[0].kind).toBe('field')
-    // …and the block is not listed beside it.
-    expect(rows.filter(row => row.kind === 'block')).toHaveLength(0)
-
-    // A query naming a block that HAS fields can never produce a block row, and
-    // that is a property of the addressing rather than a gap: every field's
-    // dotted path begins with its own block name, so the block always matches
-    // and so do all of its fields. Which means the block row is reachable in
-    // exactly one shape — a block with NO fields, which `customRoles` is on a
-    // fresh install. That is the case worth pinning: without it, "search for
-    // customRoles" would return only a `no-results` row, which is a lie, because
-    // the block exists and has nothing in it yet.
-    const empty = discoverConfig({ customRoles: [] })
-    const rows2 = searchOptions(empty, 'customRoles')
-    expect(rows2.map(row => row.kind)).toEqual(['block', 'back'])
-    expect(blockMatches(empty.blocks[0], 'customRoles')).toBe(true)
-    expect(filterConfigFields(empty, 'customRoles')).toEqual([])
-    expect(filterConfigBlocks(empty, 'customRoles').map(b => b.name)).toEqual(['customRoles'])
-  })
-
-  it('answers a search that matched NOTHING with a quotable row that goes somewhere', () => {
-    const rows = searchOptions(discovery, 'zzznotasetting')
-    // A `select` with zero options is a dialog the user can see but not leave,
-    // and it looks exactly like a failed load. So the miss is a ROW.
-    expect(rows.map(row => row.kind)).toEqual(['no-results', 'back'])
-    const miss = rows[0]
-    if (miss.kind !== 'no-results') throw new Error('the miss is not a no-results row')
-
-    // It QUOTES the query: a user who does not remember what they typed cannot
-    // otherwise tell a typo from a missing setting.
-    expect(configOptionTitle(miss, 'global')).toBe('No setting matches "zzznotasetting"')
-    // And it says what the search COVERS, so a user who assumed it searched
-    // values learns that it does not.
-    expect(configOptionDescription(miss, config, config, false)).toBe(
-      'Searches block names and setting names'
-    )
-    // Selectable, and it leads somewhere real.
-    expect(configSelect({ kind: 'search', query: 'zzznotasetting' }, miss)).toEqual({
-      kind: 'to',
-      screen: { kind: 'blocks' }
-    })
-  })
-
-  it('is one escape from the hub, and an unmatched search screen is still escapable', () => {
-    // The "at most two escapes to the hub" guarantee. A search that had to be
-    // left before a result could be opened would push the deepest screen in the
-    // flow to three.
-    expect(configUp({ kind: 'search', query: 'budget' })).toEqual({ kind: 'blocks' })
-    // `search` is a screen rather than an instant for the same reason the editor
-    // is: "can the user get out of here" has to be answerable, and it cannot be
-    // answered for something that is not a state.
-    expect(configScreenTitle({ kind: 'search', query: 'budget' }, 0)).toBe(
-      'Nexus configuration — search "budget"'
-    )
-  })
-
-  it('reaches the search screen from the hub\'s SECOND row, before any block', () => {
-    // Positional, and load-bearing: the hub lists every config key, so it is
-    // past a screenful on any real config. A search row below the blocks would
-    // sit under the fold on every device — a feature nobody finds.
-    const hub = blockOptions(discovery, 'global')
-    expect(hub[0].kind).toBe('scope')
-    expect(hub[1].kind).toBe('search')
-    const firstBlock = hub.findIndex(option => option.kind === 'block')
-    expect(firstBlock).toBeGreaterThan(1)
-    expect(hub.filter(option => option.kind === 'search')).toHaveLength(1)
-  })
-
-  it('asks the host for a query rather than navigating to a search it has not been given', () => {
-    // The `ask` outcome exists so the flow never invents a state containing a
-    // string it never decided. An empty-query screen would be a real screen that
-    // matched EVERYTHING, so a dismissed prompt would drop the user into a list
-    // of the whole config.
-    const outcome = configSelect({ kind: 'blocks' }, { kind: 'search' })
-    expect(outcome.kind).toBe('ask')
-    if (outcome.kind !== 'ask') throw new Error('the search row did not ask')
-    expect(outcome.screen).toEqual({ kind: 'search', query: '' })
-  })
-})
-
 // ── Dirty badges ────────────────────────────────────────────────────
 
 describe('config flow dirty counts', () => {
@@ -1217,16 +1229,21 @@ describe('config flow dirty counts', () => {
   it('marks a dirty block with a NUMBER and a glyph, and leaves a clean one exactly as it was', () => {
     // Readable WITHOUT colour: the glyph alone is a mark with no magnitude, and
     // "which block did I change" is a question a count answers.
+    //
+    // IN THE FOOTER, like every other current value — the dirty count is a number
+    // about the block's state, and the footer is the column the host right-aligns.
+    // Putting it back in the description would be a "consistency" change that
+    // un-columns the one screen with a number on every row.
     const budget = blockOptions(discovery, 'global').find(o => o.kind === 'block' && o.block.name === 'budget')
-    const clean = configOptionDescription(budget as never, config, config, true)
+    const clean = configOptionFooter(budget as never, config, config)
     expect(clean).toMatch(/^\d+ settings$/)
 
     const staged = setConfigValue(config, ['budget', 'maxTotalCost'], 25)
-    const dirty = configOptionDescription(budget as never, staged, config, true)
+    const dirty = configOptionFooter(budget as never, staged, config)
     expect(dirty).toMatch(/^\d+ settings {2}1 changed {2}\*$/)
     // A block nobody touched is untouched, so a `*` still means "not on disk".
     const models = blockOptions(discovery, 'global').find(o => o.kind === 'block' && o.block.name === 'models')
-    expect(configOptionDescription(models as never, staged, config, true)).toMatch(/^\d+ settings$/)
+    expect(configOptionFooter(models as never, staged, config)).toMatch(/^\d+ settings$/)
   })
 
   it('reports Save as clean only when the draft is clean, and never counts', () => {
@@ -1442,6 +1459,32 @@ describe('the config flow adapter in src/tui.tsx', () => {
     expect(code).not.toContain('keymap.layer(() => ({ target')
   })
 
+  it('delegates every slot of a row to config-flow, and has no search screen of its own', async () => {
+    const code = await codeOnly()
+    // THE ROUTING IS A DECISION, so it is in the tested file. `toDialogRow` is
+    // allowed to call the three functions and to spread their `undefined`s; it is
+    // not allowed to assemble a title, a description or a footer itself, because
+    // a string built here is a string no test can reach.
+    expect(code).toContain('configOptionTitle(')
+    expect(code).toContain('configOptionDescription(')
+    expect(code).toContain('configOptionFooter(')
+    expect(code).toContain('configHubCurrent(')
+    // No string literal that looks like a row. A title or a footer written out
+    // here would be one this file cannot assert anything about.
+    expect(code).not.toMatch(/title:\s*['"`]/)
+    expect(code).not.toMatch(/footer:\s*['"`]/)
+    // And the search screen is GONE from the adapter, not merely unused. The
+    // host filters every `select` live, so a `prompt` standing in for a filter is
+    // a keystroke between the user and the thing they meant to type. Asserted
+    // over the whole file because reintroducing it is a file-level choice.
+    expect(code).not.toContain("kind: 'search'")
+    expect(code).not.toContain("'ask'")
+    // The host's own filter is left switched ON, which is what makes the removal
+    // safe: no `skipFilter`, no `renderFilter`.
+    expect(code).not.toContain('skipFilter')
+    expect(code).not.toContain('renderFilter')
+  })
+
   it('has exactly two write paths, and the flow\'s is the save branch', async () => {
     const code = await withStrings()
     // `persistConfig` is the only thing that writes a file. There are two call