jeo-code 0.7.18 → 0.7.20

package/CHANGELOG.md

@@ -6,6 +6,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.7.20] - 2026-06-26
+_OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget._
+
+### Added
+- **IDF-weighted lexical scoring (`buildCorpusStats` / `tokenIdf`).** `src/agent/memory.ts` adds `CorpusStats` (corpus size + per-token document frequency) built once per retrieval pass, and BM25-style non-negative IDF `ln(1 + (N − df + 0.5)/(df + 0.5))`. `scoreConcept` now takes optional `stats` and scales each token's field weight (title ≫ tags ≫ type/description ≫ body) by its IDF, so a rare specific term outranks a concept hit only by common filler. Always > 0 for a present token, so the score-presence semantics the failure-gate and filters depend on are preserved; omitting `stats` keeps the raw field-weighted count.
+- **Reciprocal Rank Fusion (`reciprocalRankFusion`, k=60).** Fuses several ranked id-lists into one score map — each list contributes `1/(k + rank)` summed across lists, rank-based (not score-based) so a strong lexical hit and a strong graph-proximity hit combine on equal, scale-free footing, and a concept ranked in BOTH channels rises above one strong in only one. Tunable `k`; an empty channel is a no-op.
+- **Graph-proximity channel (`graphProximityOrder`).** Ranks concepts by how many distinct query-hit seeds reach them via 1-hop links (using the public `expandByGraph` API), the local stand-in for memsearch's dense-vector channel: a strongly-connected neighbour surfaces even when its own lexical score is weak. Input order breaks ties.
+
+### Changed
+- **`priorityOrder` fuses lexical ⊕ graph by RRF instead of raw score + a boolean `related` flag.** The failure-first and high-confidence "core" tiers are unchanged; below them, the prior `score`-then-`related` ordering is replaced by the fused RRF rank, with input order as the stable final tiebreak. `searchConcepts` now IDF-weights via `buildCorpusStats` too. The failure boost still only fires on an actual query hit (score > 0).
+
+### Verified
+- `bun run typecheck` clean; full suite green — 2022 pass / 0 fail across 234 files — including new `test/memory-search-okf.test.ts` cases (`buildCorpusStats` document-frequency counting, `scoreConcept` IDF scaling, a rare term outranking a higher raw-weight common term, `reciprocalRankFusion` cross-channel summation + tunable `k` + empty-channel no-op, graph proximity lifting a multiply-linked hub above an unlinked equal-score concept). `scripts/rrf-runtime-check.ts` drives the production `memoryPromptSection` against a real on-disk bundle.
+
+
+## [0.7.19] - 2026-06-26
+_The live model picker gains gajae-code's `/model` provider tabs, and skill invocation is consolidated onto a single `$` entrypoint. The picker now shows an `ALL` tab plus one tab per provider that `tab`/`shift+tab` cycles, and skills (including their declared aliases) are invoked only via `$` — the slash palette stays builtins-only._
+
+### Added
+- **`/model` live picker gets a provider/group tab bar (gajae-code parity).** `src/tui/components/select-list.ts` adds a synthetic `ALL_TAB` first tab plus one tab per distinct item `group`, a `tabList()`/`activeTab()`/`cycleTab()` API, and tab-scoped visibility in `computeVisible()`. `renderSelectList` gains a `showTabs` option that draws the tab bar (active tab highlighted) and a `tab provider` key hint; `renderLiveModelPicker` (`live-model-picker.ts`) enables it. `runLaunchCommand` (`src/commands/launch.ts`) wires the `tab` key (with `shift+tab` to step back) into the picker key handler.
+
+### Changed
+- **Skills are invoked ONLY via the `$` entrypoint — declared aliases become `$`-invocable, never `/` commands.** This reverses 0.7.18's slash-alias dispatch: `src/skills/catalog.ts` replaces `parseSkillSlashInvocation` with `getSkillByDollarToken` (resolve by exact name → exact declared alias without its leading `/` → unique name prefix), and `parseSkillInvocation` now also matches a declared alias, so `$obsidian-capture` loads the skill that declares `/obsidian-capture`. `runLaunchCommand` drops every `/`-alias dispatch path (one-shot and REPL), leaves `skillSlashDetails` empty so the slash menu stays builtins-only, and surfaces declared-alias tokens in `$` autocomplete via `resolvedSkillTokens`.
 
 ## [0.7.18] - 2026-06-26
 _Slash-command discovery and the `/model` flow reach gajae-code parity. The slash palette/autocomplete now fuzzy-matches command names (with a description fallback for intent-style queries), resolved skills can contribute their own `/aliases` as real dispatchable commands, and `/model` runs gjc's two-menu target → reasoning flow so a picked model can be assigned to the default or any subagent role with its own thinking budget._

package/README.ja.md

@@ -205,11 +205,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
+- **[0.7.19]** (2026-06-26) — The live model picker gains gajae-code's `/model` provider tabs, and skill invocation is consolidated onto a single `$` entrypoint. The picker now shows an `ALL` tab plus one tab per provider that `tab`/`shift+tab` cycles, and skills (including their declared aliases) are invoked only via `$` — the slash palette stays builtins-only.
 - **[0.7.18]** (2026-06-26) — Slash-command discovery and the `/model` flow reach gajae-code parity. The slash palette/autocomplete now fuzzy-matches command names (with a description fallback for intent-style queries), resolved skills can contribute their own `/aliases` as real dispatchable commands, and `/model` runs gjc's two-menu target → reasoning flow so a picked model can be assigned to the default or any subagent role with its own thinking budget.
 - **[0.7.17]** (2026-06-25) — Developer workflow parity (gjc `dev:link`/`dev:doctor`, adapted for jeo's zero-native-dep Bun runtime): the global `jeo` command can be linked to run this checkout's source hot to every edit, with a drift doctor that flags when `jeo` resolves to a compiled binary or an installed copy instead. README gains "Skill migration and bundled skill inspection" + "Development" sections. Also ships OKF concept-memory search/scoring with budget-aware injection and a round of workflow-prompt hardening (anti-punt, todo-first planning, verdict discipline) that keeps every loop escape hatch intact.
 - **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
-- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
-- **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -205,11 +205,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
+- **[0.7.19]** (2026-06-26) — The live model picker gains gajae-code's `/model` provider tabs, and skill invocation is consolidated onto a single `$` entrypoint. The picker now shows an `ALL` tab plus one tab per provider that `tab`/`shift+tab` cycles, and skills (including their declared aliases) are invoked only via `$` — the slash palette stays builtins-only.
 - **[0.7.18]** (2026-06-26) — Slash-command discovery and the `/model` flow reach gajae-code parity. The slash palette/autocomplete now fuzzy-matches command names (with a description fallback for intent-style queries), resolved skills can contribute their own `/aliases` as real dispatchable commands, and `/model` runs gjc's two-menu target → reasoning flow so a picked model can be assigned to the default or any subagent role with its own thinking budget.
 - **[0.7.17]** (2026-06-25) — Developer workflow parity (gjc `dev:link`/`dev:doctor`, adapted for jeo's zero-native-dep Bun runtime): the global `jeo` command can be linked to run this checkout's source hot to every edit, with a drift doctor that flags when `jeo` resolves to a compiled binary or an installed copy instead. README gains "Skill migration and bundled skill inspection" + "Development" sections. Also ships OKF concept-memory search/scoring with budget-aware injection and a round of workflow-prompt hardening (anti-punt, todo-first planning, verdict discipline) that keeps every loop escape hatch intact.
 - **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
-- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
-- **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -232,11 +232,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
+- **[0.7.19]** (2026-06-26) — The live model picker gains gajae-code's `/model` provider tabs, and skill invocation is consolidated onto a single `$` entrypoint. The picker now shows an `ALL` tab plus one tab per provider that `tab`/`shift+tab` cycles, and skills (including their declared aliases) are invoked only via `$` — the slash palette stays builtins-only.
 - **[0.7.18]** (2026-06-26) — Slash-command discovery and the `/model` flow reach gajae-code parity. The slash palette/autocomplete now fuzzy-matches command names (with a description fallback for intent-style queries), resolved skills can contribute their own `/aliases` as real dispatchable commands, and `/model` runs gjc's two-menu target → reasoning flow so a picked model can be assigned to the default or any subagent role with its own thinking budget.
 - **[0.7.17]** (2026-06-25) — Developer workflow parity (gjc `dev:link`/`dev:doctor`, adapted for jeo's zero-native-dep Bun runtime): the global `jeo` command can be linked to run this checkout's source hot to every edit, with a drift doctor that flags when `jeo` resolves to a compiled binary or an installed copy instead. README gains "Skill migration and bundled skill inspection" + "Development" sections. Also ships OKF concept-memory search/scoring with budget-aware injection and a round of workflow-prompt hardening (anti-punt, todo-first planning, verdict discipline) that keeps every loop escape hatch intact.
 - **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
-- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
-- **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -205,11 +205,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.20]** (2026-06-26) — OKF concept-memory retrieval gains a hybrid reranker ported from memsearch. Injection priority no longer rides one raw keyword score — it fuses two complementary ranked channels by Reciprocal Rank Fusion (RRF): IDF-weighted lexical relevance (the sparse/BM25 channel, so rare discriminating terms steer recall) and concept-graph proximity (the local dense/semantic-neighbour channel, so a hub linked from multiple query hits surfaces even with no keyword of its own). All embedding-free and deterministic, layered atop the existing failure-first tier and pinned-invariant reserved budget.
+- **[0.7.19]** (2026-06-26) — The live model picker gains gajae-code's `/model` provider tabs, and skill invocation is consolidated onto a single `$` entrypoint. The picker now shows an `ALL` tab plus one tab per provider that `tab`/`shift+tab` cycles, and skills (including their declared aliases) are invoked only via `$` — the slash palette stays builtins-only.
 - **[0.7.18]** (2026-06-26) — Slash-command discovery and the `/model` flow reach gajae-code parity. The slash palette/autocomplete now fuzzy-matches command names (with a description fallback for intent-style queries), resolved skills can contribute their own `/aliases` as real dispatchable commands, and `/model` runs gjc's two-menu target → reasoning flow so a picked model can be assigned to the default or any subagent role with its own thinking budget.
 - **[0.7.17]** (2026-06-25) — Developer workflow parity (gjc `dev:link`/`dev:doctor`, adapted for jeo's zero-native-dep Bun runtime): the global `jeo` command can be linked to run this checkout's source hot to every edit, with a drift doctor that flags when `jeo` resolves to a compiled binary or an installed copy instead. README gains "Skill migration and bundled skill inspection" + "Development" sections. Also ships OKF concept-memory search/scoring with budget-aware injection and a round of workflow-prompt hardening (anti-punt, todo-first planning, verdict discipline) that keeps every loop escape hatch intact.
 - **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
-- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
-- **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.18",
+  "version": "0.7.20",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/AGENTS.md

@@ -18,7 +18,7 @@ The core runtime loop, tool registry, session management, and state persistence
 | `json.ts` | Brief description of purpose |
 | `loop.ts` | The primary execution loop orchestrating model calls and tool execution |
 | `loop-guards.ts` | Intermediate-judgment classification (gjc ultragoal-guard parity): named `GuardState` taxonomy, `GUARD_LIMITS` thresholds, and pure classifiers (`isVerificationSignal`, `repeatHint`, `classifyDoneGate` — incl. `done_stale_verification` for a passing test/build that predates the last edit) consumed by `engine.ts` |
-| `memory.ts` | OKF concept-bundle memory: session distill, query-aware budget injection (failure-first `priorityOrder` + pinned-invariant reserved budget), mid-loop `recordFailedAttempt` capture, shared `upsertConceptFile` writer, legacy MEMORY.md migration (`migrateLegacyMemory`) + `JEO_MEMORY_LEGACY` rollback toggle |
+| `memory.ts` | OKF concept-bundle memory: session distill, query-aware budget injection with a **hybrid reranker ported from memsearch** — `priorityOrder` fuses two ranked channels via `reciprocalRankFusion` (RRF, k=60): lexical IDF relevance (`buildCorpusStats`/`scoreConcept`, the sparse/BM25 channel so rare discriminating terms steer retrieval) ⊕ graph proximity (`graphProximityOrder`, the local dense/semantic-neighbour channel — a hub linked from multiple query hits surfaces even with no keyword of its own); all embedding-free, deterministic, atop the failure-first tier + pinned-invariant reserved budget. Plus mid-loop `recordFailedAttempt` capture, shared `upsertConceptFile` writer, legacy MEMORY.md migration (`migrateLegacyMemory`) + `JEO_MEMORY_LEGACY` rollback toggle |
 | `memory-okf.ts` | OKF v0.1 format layer: frontmatter parse/serialize, concept IDs, conformance validation |
 | `memory-graph.ts` | Concept cross-link graph: build/expand (1-hop search), broken-link-tolerant lint, optional graphify detection |
 | `model-recency.ts` | Brief description of purpose |

package/src/agent/memory.ts

@@ -17,7 +17,7 @@ import { callLlm, type Message } from "./loop";
 import { jeoEnv } from "../util/env";
 import { parseConcept, serializeConcept, slugify, isReservedFile, conceptId } from "./memory-okf";
 import { tryExtractJsonObject } from "./json";
-import { buildConceptGraph, expandByGraph, lintConceptGraph, type GraphLintReport } from "./memory-graph";
+import { buildConceptGraph, expandByGraph, lintConceptGraph, type ConceptGraph, type GraphLintReport } from "./memory-graph";
 
 /** On-disk document cap — the distill prompt instructs the model to stay under it. */
 export const MEMORY_MAX_CHARS = 6_000;
@@ -314,9 +314,56 @@ function tokenize(query?: string): string[] {
   return Array.from(new Set((query.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter(t => t.length >= 3)));
 }
 
+/** Corpus statistics for IDF (inverse document frequency) weighting: total concept
+ *  count `n` and per-token document frequency `df` (how many concepts' searchable
+ *  text contains the token). Built once per retrieval pass over the loaded bundle. */
+export interface CorpusStats {
+  n: number;
+  df: Map<string, number>;
+}
+
+/** Lowercased searchable text of a concept (title + tags + type + description +
+ *  body) — the field corpus over which document frequency is measured. */
+function searchableText(concept: Concept): string {
+  return [concept.title, concept.tags.join(" "), concept.type, concept.description, concept.body]
+    .join(" ")
+    .toLowerCase();
+}
+
+/** Build IDF corpus stats from the concept set: per distinct token, how many
+ *  concepts contain it. Pure and deterministic — no embeddings, no network
+ *  (memsearch's hybrid BM25 contribution adapted to jeo's local-first bundle). */
+export function buildCorpusStats(concepts: Concept[]): CorpusStats {
+  const df = new Map<string, number>();
+  for (const c of concepts) {
+    const text = searchableText(c);
+    // Distinct tokens of THIS concept (length ≥ 3, mirroring tokenize) so each
+    // concept contributes at most 1 to a token's document frequency.
+    const seen = new Set((text.match(/[a-z0-9]+/g) ?? []).filter(t => t.length >= 3));
+    for (const t of seen) df.set(t, (df.get(t) ?? 0) + 1);
+  }
+  return { n: concepts.length, df };
+}
+
+/** BM25-style non-negative IDF for a token: ln(1 + (N − df + 0.5)/(df + 0.5)).
+ *  A token that discriminates (appears in few concepts) outweighs a token that
+ *  appears everywhere — so a query's rare, specific terms steer retrieval instead
+ *  of common filler. Always > 0 for a present token (df ≥ 1), so the score > 0
+ *  presence semantics the failure-gate and filters depend on are preserved. A
+ *  token absent from the corpus only ever contributes through a field it does not
+ *  match (weight 0), so its IDF is moot; we floor df at the token's own presence. */
+function tokenIdf(token: string, stats: CorpusStats): number {
+  const df = stats.df.get(token) ?? 1;
+  return Math.log(1 + (stats.n - df + 0.5) / (df + 0.5));
+}
+
 /** Relevance score of a concept against query tokens. Field weights mirror
- *  llm-wiki's retrieval bias (title ≫ tags ≫ type/description ≫ body). 0 = no hit. */
-export function scoreConcept(concept: Concept, tokens: string[]): number {
+ *  llm-wiki's retrieval bias (title ≫ tags ≫ type/description ≫ body). When
+ *  `stats` is supplied, each token's field weight is scaled by its corpus IDF
+ *  (memsearch-style BM25 weighting) so a rare discriminating term ranks a concept
+ *  above one hit only by common tokens. Without `stats` this is the raw
+ *  field-weighted presence count (IDF = 1). 0 = no hit. */
+export function scoreConcept(concept: Concept, tokens: string[], stats?: CorpusStats): number {
   if (tokens.length === 0) return 0;
   const title = concept.title.toLowerCase();
   const desc = concept.description.toLowerCase();
@@ -325,70 +372,127 @@ export function scoreConcept(concept: Concept, tokens: string[]): number {
   const tags = concept.tags.map(t => t.toLowerCase());
   let score = 0;
   for (const t of tokens) {
-    if (title.includes(t)) score += 5;
-    if (tags.some(tag => tag.includes(t))) score += 3;
-    if (type.includes(t)) score += 2;
-    if (desc.includes(t)) score += 2;
-    if (body.includes(t)) score += 1;
+    let weight = 0;
+    if (title.includes(t)) weight += 5;
+    if (tags.some(tag => tag.includes(t))) weight += 3;
+    if (type.includes(t)) weight += 2;
+    if (desc.includes(t)) weight += 2;
+    if (body.includes(t)) weight += 1;
+    score += stats ? weight * tokenIdf(t, stats) : weight;
   }
   return score;
 }
 
 /** Search the bundle's concepts for a query, returning the relevant ones (score > 0)
- *  highest-score first. A type/tags/title/body keyword match all contribute. */
+ *  highest-score first. A type/tags/title/body keyword match all contribute, scaled
+ *  by corpus IDF so the most discriminating hits rank first. */
 export function searchConcepts(concepts: Concept[], query: string): { concept: Concept; score: number }[] {
   const tokens = tokenize(query);
+  const stats = buildCorpusStats(concepts);
   return concepts
-    .map(concept => ({ concept, score: scoreConcept(concept, tokens) }))
+    .map(concept => ({ concept, score: scoreConcept(concept, tokens, stats) }))
     .filter(r => r.score > 0)
     .sort((a, b) => b.score - a.score);
 }
 
+/** Reciprocal Rank Fusion constant (memsearch / TREC standard k=60): dampens any
+ *  single list's contribution so no one channel can dominate the fused order. */
+const RRF_K = 60;
+
+/** Fuse several ranked id-lists into one score map via Reciprocal Rank Fusion:
+ *  each list contributes 1/(k + rank) (rank 0-based) for the ids it ranks, summed
+ *  across lists. Rank-based (not score-based), so a strong lexical hit and a strong
+ *  graph-proximity hit combine on equal, scale-free footing — memsearch's hybrid
+ *  reranker (BM25 ⊕ dense) adapted to jeo's lexical ⊕ concept-graph channels. An id
+ *  ranked in no list simply gets 0. */
+export function reciprocalRankFusion(lists: string[][], k = RRF_K): Map<string, number> {
+  const fused = new Map<string, number>();
+  for (const list of lists) {
+    list.forEach((id, rank) => {
+      fused.set(id, (fused.get(id) ?? 0) + 1 / (k + rank));
+    });
+  }
+  return fused;
+}
+
+/** Rank concepts by graph proximity to the query seeds: the more distinct seeds a
+ *  concept is reachable from (itself, or a 1-hop link to/from a seed), the higher it
+ *  ranks. This is the local stand-in for memsearch's dense-vector channel — a
+ *  strongly-connected neighbour surfaces even when its OWN lexical score is weak,
+ *  the way a semantic neighbour does under dense retrieval. Only concepts reachable
+ *  from ≥1 seed are returned; input order breaks ties. Uses the public graph API
+ *  (expandByGraph) so it stays correct if the graph internals change. */
+function graphProximityOrder(concepts: Concept[], seedIds: string[], graph: ConceptGraph): string[] {
+  if (seedIds.length === 0) return [];
+  const reach = new Map<string, number>();
+  for (const seed of seedIds) {
+    for (const id of expandByGraph([seed], graph, 1)) reach.set(id, (reach.get(id) ?? 0) + 1);
+  }
+  const index = new Map(concepts.map((c, i) => [conceptId(c.relPath), i] as const));
+  return [...reach.entries()]
+    .sort((a, b) => b[1] - a[1] || (index.get(a[0]) ?? 0) - (index.get(b[0]) ?? 0))
+    .map(([id]) => id);
+}
+
+
 /** Priority order for injection. Failure-first: a query-relevant FailedAttempt is
  *  surfaced AHEAD of everything else — resurfacing a known dead end is higher-leverage
  *  than reinforcing what already works ("못하는 게 없도록" — close the gaps, don't just
  *  polish strengths), and it is the mechanism by which the loop gets more precise the
  *  more it repeats (llm-wiki: accumulated failure knowledge sharpens future runs). Then
- *  high-confidence "core" concepts, then query relevance (descending), then concepts the
- *  relevant ones LINK TO (1-hop graph expansion — Sprint 04: a directly-hit concept pulls
- *  its neighbours in as context ahead of unrelated noise), preserving input order as a
- *  stable tiebreak. The failure boost only fires when the query actually hits the concept
- *  (score > 0), so an unrelated FailedAttempt never crowds out relevant context. */
+ *  high-confidence "core" concepts, then HYBRID relevance.
+ *
+ *  Hybrid relevance (memsearch's reranker, ported): two complementary ranked channels
+ *  are fused by Reciprocal Rank Fusion instead of one raw score with a boolean boost —
+ *    (1) lexical: query-hit concepts ranked by IDF-weighted score (the "sparse"/BM25
+ *        channel), and
+ *    (2) graph proximity: concepts reachable from the query-hit seeds via 1-hop links,
+ *        ranked by how many seeds reach them (the local "dense"/semantic-neighbour
+ *        channel — Sprint 04 graph expansion, now a ranked signal, not just a flag).
+ *  Fusing by rank lets a strongly-linked neighbour with a weak lexical score still
+ *  outrank unrelated noise, and lets a concept that is BOTH a lexical hit and a graph
+ *  hub rise above a concept strong in only one channel. Input order is the stable
+ *  final tiebreak. The failure boost only fires when the query actually hits the
+ *  concept (score > 0), so an unrelated FailedAttempt never crowds out relevant
+ *  context. */
 function priorityOrder(concepts: Concept[], query?: string): Concept[] {
   const tokens = tokenize(query);
-  // 1-hop graph expansion: seed from concepts the query directly hits, then mark
-  // their link-neighbours as "related" so they outrank unrelated zero-score noise.
-  const related = new Set<string>();
-  if (tokens.length > 0) {
-    const graph = buildConceptGraph(concepts);
-    const seeds = concepts.filter(c => scoreConcept(c, tokens) > 0).map(c => conceptId(c.relPath));
-    for (const id of expandByGraph(seeds, graph, 1)) related.add(id);
+  const stats = buildCorpusStats(concepts);
+  const scored = concepts.map(c => ({ c, id: conceptId(c.relPath), score: scoreConcept(c, tokens, stats) }));
+
+  // Channel 1 — lexical ("sparse"/BM25): query-hit concepts, IDF score descending.
+  // Stable sort keeps input order on ties.
+  const lexicalOrder = scored.filter(s => s.score > 0).slice().sort((a, b) => b.score - a.score).map(s => s.id);
+
+  // Channel 2 — graph proximity ("dense"): neighbours of the query-hit seeds.
+  let graphOrder: string[] = [];
+  if (tokens.length > 0 && lexicalOrder.length > 0) {
+    graphOrder = graphProximityOrder(concepts, lexicalOrder, buildConceptGraph(concepts));
   }
-  return concepts
-    .map((concept, i) => {
-      const score = scoreConcept(concept, tokens);
-      return {
-        concept,
-        i,
-        // Query-relevant past failure → resurface first so the loop is reminded of
-        // what NOT to repeat for the current task. Gated on score > 0: a stale,
-        // unrelated dead end stays out of the way.
-        failure: concept.type === "FailedAttempt" && score > 0,
-        core: concept.confidence === "high",
-        score,
-        related: related.has(conceptId(concept.relPath)),
-      };
-    })
+
+  const fused = reciprocalRankFusion([lexicalOrder, graphOrder]);
+
+  return scored
+    .map(({ c, id, score }, i) => ({
+      concept: c,
+      i,
+      // Query-relevant past failure → resurface first so the loop is reminded of
+      // what NOT to repeat for the current task. Gated on score > 0: a stale,
+      // unrelated dead end stays out of the way.
+      failure: c.type === "FailedAttempt" && score > 0,
+      core: c.confidence === "high",
+      rrf: fused.get(id) ?? 0,
+    }))
     .sort((a, b) => {
       if (a.failure !== b.failure) return a.failure ? -1 : 1;
       if (a.core !== b.core) return a.core ? -1 : 1;
-      if (b.score !== a.score) return b.score - a.score;
-      if (a.related !== b.related) return a.related ? -1 : 1;
+      if (b.rrf !== a.rrf) return b.rrf - a.rrf;
       return a.i - b.i;
     })
     .map(s => s.concept);
 }
 
+
 /** Group items by their `type` into ordered `{ header, list }` sections: TYPE_LAYOUT
  *  order first, then any unknown types under their raw type name (lenient). The one
  *  place that encodes the section ordering — shared by render and index. */

package/src/commands/launch.ts

@@ -14,7 +14,7 @@ import { runDeepInterviewEngine, type DeepInterviewEngineOptions } from "./deep-
 import { runRalplanEngine, type RalplanEngineOptions } from "./ralplan";
 import { runTeamEngine, type TeamEngineOptions } from "./team";
 import { runUltragoalEngine, type UltragoalEngineOptions } from "./ultragoal";
-import { skillsPromptSection, loadSkills, buildSkillTask, workflowSkillsForPrompt, parseSkillInvocation, parseSkillChain, parseSkillSlashInvocation, skillSlashAliases, looksLikeSkillEcho, skillInvocationCard, type SkillDoc, type SkillInvocation } from "../skills/catalog";
+import { skillsPromptSection, loadSkills, buildSkillTask, workflowSkillsForPrompt, parseSkillInvocation, parseSkillChain, skillSlashAliases, looksLikeSkillEcho, skillInvocationCard, type SkillDoc, type SkillInvocation } from "../skills/catalog";
 import { formatForgeBox, scaleForgeWidth } from "../tui/components/forge";
 import { interactiveOAuthLogin } from "./auth";
 import { logoutOAuth, OAUTH_PROVIDERS, API_KEY_ONLY_PROVIDERS, setApiKey } from "../auth";
@@ -522,27 +522,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
   const workflowSkills = workflowSkillsForPrompt(resolvedSkills);
   const resolvedSkillNames = resolvedSkills.map(s => s.name);
-  // Skills can ADD `/` commands: every slash alias a resolved skill declares (frontmatter
-  // `aliases:`/`slash:`) becomes a real, dispatchable palette command grouped under "skills",
-  // so installing a skill extends the slash menu, autocomplete, and previews — not just `$<name>`.
-  // First declarer of an alias wins (aliases are owner-scoped, so cross-skill collisions are rare).
+  // Skills are invoked ONLY via the `$` entrypoint — never as `/` commands. A skill's declared
+  // aliases (frontmatter `aliases:`/`slash:`) are additionally `$`-invocable (`/obsidian-capture`
+  // → `$obsidian-capture`), so they extend `$` autocomplete (see resolvedSkillTokens) rather than
+  // the slash palette. The slash menu stays builtins-only, hence skillSlashDetails is empty.
   const skillSlashDetails: SlashCommandInfo[] = [];
-  {
-    const seenAlias = new Set<string>();
-    for (const s of resolvedSkills) {
-      for (const alias of skillSlashAliases(s)) {
-        const key = alias.toLowerCase();
-        if (seenAlias.has(key)) continue;
-        seenAlias.add(key);
-        skillSlashDetails.push({
-          command: alias,
-          usage: `${alias} [intent]`,
-          description: `${s.name} skill — ${s.summary}`,
-          group: "skills",
-        });
-      }
-    }
-  }
+  // Declared-alias tokens (the alias text without its leading `/`), surfaced in `$` autocomplete
+  // next to skill names so installing a skill grows the `$` menu, not the `/` menu.
+  const resolvedSkillTokens = [...new Set([
+    ...resolvedSkillNames,
+    ...resolvedSkills.flatMap(s => skillSlashAliases(s).map(a => a.replace(/^\//, ""))),
+  ])];
 
   const protocol = buildToolProtocol(allowedTools);
   const preamble = flags.systemPrompt ?? "You are the jeo, an interactive coding agent.\nAccomplish the user's request by calling tools and verifying your work.";
@@ -1277,18 +1267,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
       return;
     }
-    // A `$skill` invocation resolves to a single skill.
+    // A `$skill` invocation resolves to a single skill (by name, declared alias, or unique prefix).
     const skillInvocation = parseSkillInvocation(messageContent, resolvedSkills);
     if (skillInvocation) {
       await runOneSkillShot(skillInvocation);
       return;
     }
-    // A declared skill `/alias` (e.g. `jeo "/obsidian-capture note"`) dispatches the owning skill.
-    const slashSkill = parseSkillSlashInvocation(messageContent, resolvedSkills);
-    if (slashSkill) {
-      await runOneSkillShot(slashSkill);
-      return;
-    }
     try {
       const { reply, rendered, usage } = await runTurn(messageContent, shouldUseOneShotTui(flags.noTui));
       if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
@@ -1483,7 +1467,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       slashCommands: [...base.slashCommands, ...skillSlashDetails.map(d => d.command)],
       liveModels: liveModelsCache ? flattenModels(liveModelsCache).map(e => e.model) : [],
       aliases: aliasNames,
-      skillNames: resolvedSkillNames,
+      skillNames: resolvedSkillTokens,
       modelsForProvider: p => liveModelsCache?.find(r => r.provider === p)?.models ?? [],
       mentionPaths,
     };
@@ -2236,7 +2220,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
   const runSelectPicker = async <T>(
     render: (cols: number, rows: number) => string[],
-    onKey: (ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean } | undefined) => boolean | undefined,
+    onKey: (ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean } | undefined) => boolean | undefined,
   ): Promise<void> => {
     pickerActive = true; // closes the readline output gate for the picker's lifetime
     disarmPreview();
@@ -2305,7 +2289,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     process.stdout.on("resize", onPickerResize);
     try {
       await new Promise<void>(resolve => {
-        const handler = (ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean } | undefined) => {
+        const handler = (ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean } | undefined) => {
           const done = onKey(ch, key);
           if (done) {
             process.stdin.off("keypress", handler);
@@ -2420,6 +2404,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           list.page(1, 6);
           return false;
         }
+        if (key?.name === "tab") {
+          // gajae-code parity: cycle the provider tab (shift+tab steps back).
+          list.cycleTab(key.shift ? -1 : 1);
+          return false;
+        }
         if (key?.name === "backspace") {
           list.backspace();
           return false;
@@ -4407,15 +4396,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
-      const aliasInvocation = parseSkillInvocation(input, resolvedSkills);
-      if (aliasInvocation?.invokedAs) {
-        try {
-          await runSkillInvocation(aliasInvocation.skill, aliasInvocation.intent, aliasInvocation.invokedAs);
-        } catch (err) {
-          console.log(`! ${(err as Error).message}`);
-        }
-        continue;
-      }
+
       // Unresolved `$skill` → suggest precisely, never silently send the typo to the model.
       // `$exact`/`$prefix`/chains already ran above; a leftover `$word` is a missed skill
       // attempt, EXCEPT `$UPPERCASE` env-var-style tokens (e.g. `$HOME`) which pass through.
@@ -4443,20 +4424,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           continue;
         }
       }
-      // A declared skill slash alias (e.g. `/obsidian-capture note`) dispatches the owning skill,
-      // passing the alias as the routing signal and the rest of the line as the intent. Placed
-      // after every built-in slash handler (built-ins win) and before the unhandled-slash fallback.
-      if (!flags.noSkills && input.startsWith("/")) {
-        const slashSkill = parseSkillSlashInvocation(input, resolvedSkills);
-        if (slashSkill) {
-          try {
-            await runSkillInvocation(slashSkill.skill, slashSkill.intent, slashSkill.invokedAs);
-          } catch (err) {
-            console.log(`! ${(err as Error).message}`);
-          }
-          continue;
-        }
-      }
+
       // Unhandled slash attempt → suggest, don't send the typo to the model.
       if (isSlashAttempt(input)) {
         const m = matchSlash(input, [...completionContext().slashCommands]);

package/src/skills/catalog.ts

@@ -521,18 +521,19 @@ export function getSkillBySlash(skills: SkillDoc[], command: string): SkillDoc |
   return skills.find(s => skillSlashAliases(s).some(a => a.toLowerCase() === q));
 }
 
-/** Resolve a leading `/alias` slash command to the skill that DECLARES it, e.g.
- *  `/obsidian-capture note text` → { skill, intent: "note text", invokedAs: "/obsidian-capture" }.
- *  Returns null when the first token is not a declared skill slash alias. This is what lets an
- *  installed skill add real, dispatchable `/` commands (not just routing-hint metadata): only the
- *  FIRST token is matched, and the rest of the line becomes the intent passed to the skill. */
-export function parseSkillSlashInvocation(input: string, skills: SkillDoc[]): SkillInvocation | null {
-  const trimmed = input.trim();
-  if (!trimmed.startsWith("/")) return null;
-  const command = trimmed.split(/\s+/, 1)[0] ?? "";
-  const skill = getSkillBySlash(skills, command);
-  if (!skill) return null;
-  return { skill, intent: trimmed.slice(command.length).trim(), invokedAs: command };
+/** Resolve a bare `$`-token (the text after `$`, no leading `$`) to a skill: exact name,
+ *  then exact declared alias (the alias compared without its leading `/`), then unique name
+ *  prefix. This makes declared aliases first-class `$` entrypoints — `$obsidian-capture`
+ *  resolves the skill that declares `/obsidian-capture` — so skills stay `$`-managed and a
+ *  declared `alias` becomes an invocable `$<alias>`, never a dispatchable `/` command. */
+export function getSkillByDollarToken(skills: SkillDoc[], token: string): SkillDoc | undefined {
+  const q = token.toLowerCase();
+  if (!q) return undefined;
+  const byName = skills.find(s => s.name.toLowerCase() === q);
+  if (byName) return byName;
+  const byAlias = skills.find(s => skillSlashAliases(s).some(a => a.replace(/^\//, "").toLowerCase() === q));
+  if (byAlias) return byAlias;
+  return uniquePrefixSkill(skills, token);
 }
 
 export interface SkillInvocation {
@@ -541,17 +542,17 @@ export interface SkillInvocation {
   invokedAs?: string;
 }
 /** Parse only an explicit `$skill` invocation. Skills are invokable ONLY via the `$`
- * entrypoint — `/` commands and slash aliases never load a skill file, and pasted SKILL.md
- * paths cannot hijack an ordinary coding request. Only the FIRST token counts, and only
- * when a skill with that exact name (or unique name prefix) is loaded; `$HOME is what?` or
- * any unknown `$word` falls through to the model as an ordinary prompt. */
+ * entrypoint — `/` commands never load a skill file, and pasted SKILL.md paths cannot
+ * hijack an ordinary coding request. Only the FIRST token counts, and only when a skill
+ * with that exact name, exact declared alias, or unique name prefix is loaded; `$HOME is
+ * what?` or any unknown `$word` falls through to the model as an ordinary prompt. */
 export function parseSkillInvocation(input: string, skills: SkillDoc[]): SkillInvocation | null {
   const trimmed = input.trim();
   if (!trimmed) return null;
 
   const command = trimmed.split(/\s+/, 1)[0] ?? "";
   if (command.length > 1 && command.startsWith("$")) {
-    const dollarSkill = getSkillFrom(skills, command.slice(1)) ?? uniquePrefixSkill(skills, command.slice(1));
+    const dollarSkill = getSkillByDollarToken(skills, command.slice(1));
     if (dollarSkill) {
       return { skill: dollarSkill, intent: trimmed.slice(command.length).trim(), invokedAs: command };
     }
@@ -563,8 +564,8 @@ export function parseSkillInvocation(input: string, skills: SkillDoc[]): SkillIn
  *  "build auth". This is what lets `$` invoke several skills in one line — they all run,
  *  in order. Scanning stops at the first non-`$` token, OR a `$UPPERCASE` env-var-style
  *  token (e.g. `$HOME`), which is left in the intent so shell-style references pass through.
- *  Each `$name` resolves by exact name then unique prefix; names that resolve to nothing go
- *  into `unresolved` (so the REPL can report every typo, not just the first). Returns null
+ *  Each `$name` resolves by exact name, exact declared alias, then unique prefix; names that
+ *  resolve to nothing go into `unresolved` (so the REPL can report every typo, not just the first). Returns null
  *  only when the input opens with no parseable `$skill` token at all. */
 export function parseSkillChain(
   input: string,
@@ -581,7 +582,7 @@ export function parseSkillChain(
     if (!tok.startsWith("$") || tok.length < 2) break;
     const name = tok.slice(1);
     if (/^[A-Z_][A-Z0-9_]*$/.test(name)) break; // env-var-style → boundary; keep in intent
-    const skill = getSkillFrom(skills, name) ?? uniquePrefixSkill(skills, name);
+    const skill = getSkillByDollarToken(skills, name);
     if (skill) invocations.push({ skill, intent: "", invokedAs: tok });
     else unresolved.push(name);
   }

package/src/tui/components/live-model-picker.ts

@@ -104,7 +104,7 @@ export function liveModelPicker(entries: PickEntry[], opts: LiveModelPickerOptio
 }
 
 export function renderLiveModelPicker(list: SelectList<PickEntry>, opts: RenderSelectOptions = {}): string[] {
-  return renderSelectList(list, { title: "Select a live model", rows: 12, ...opts });
+  return renderSelectList(list, { title: "Select a live model", rows: 12, showTabs: true, ...opts });
 }
 
 /** The five reasoning levels in display order, lightest → heaviest. */

package/src/tui/components/select-list.ts

@@ -12,6 +12,9 @@ import { padLineTo } from "./layout";
 import { visibleWidth } from "./color";
 import { truncate as truncateAnsi } from "../terminal";
 
+/** Synthetic first tab that shows every item regardless of its provider/group. */
+export const ALL_TAB = "ALL";
+
 export interface SelectItem<T> {
   value: T;
   label: string;
@@ -32,6 +35,7 @@ export interface SelectItem<T> {
 export class SelectList<T> {
   private readonly items: SelectItem<T>[];
   private query = "";
+  private tabIndex = 0; // 0 = ALL; 1..N = a provider/group tab
   private cursor = 0; // index into the *visible* list
 
   constructor(items: SelectItem<T>[]) {
@@ -45,9 +49,35 @@ export class SelectList<T> {
   }
 
   private computeVisible(): SelectItem<T>[] {
+    let list = this.items;
+    const tab = this.activeTab();
+    if (tab !== ALL_TAB) list = list.filter(i => (i.group ?? "") === tab);
     const q = this.query.trim().toLowerCase();
-    if (!q) return this.items;
-    return this.items.filter(i => i.label.toLowerCase().includes(q) || (i.group ?? "").toLowerCase().includes(q));
+    if (!q) return list;
+    return list.filter(i => i.label.toLowerCase().includes(q) || (i.group ?? "").toLowerCase().includes(q));
+  }
+
+  /** Distinct provider/group tabs: "ALL" first, then each group in first-seen order. */
+  tabList(): string[] {
+    const seen: string[] = [];
+    for (const it of this.items) {
+      if (it.group && !seen.includes(it.group)) seen.push(it.group);
+    }
+    return [ALL_TAB, ...seen];
+  }
+
+  /** Active tab — "ALL" shows everything; otherwise items of one provider/group. */
+  activeTab(): string {
+    const tabs = this.tabList();
+    return tabs[Math.min(this.tabIndex, tabs.length - 1)] ?? ALL_TAB;
+  }
+
+  /** Cycle the active provider/group tab (wraps); resets the cursor to the first match. */
+  cycleTab(dir: 1 | -1): void {
+    const n = this.tabList().length;
+    if (n <= 1) return;
+    this.tabIndex = (Math.min(this.tabIndex, n - 1) + dir + n) % n;
+    this.cursor = this.firstEnabled(this.computeVisible());
   }
 
   private firstEnabled(list: SelectItem<T>[]): number {
@@ -136,6 +166,8 @@ export interface RenderSelectOptions {
   unicode?: boolean;
   /** Apply chalk color (default true). */
   color?: boolean;
+  /** Render a provider/group tab bar (gajae-code `/model` parity) and the `tab` key hint. */
+  showTabs?: boolean;
 }
 
 /**
@@ -159,6 +191,15 @@ export function renderSelectList<T>(list: SelectList<T>, opts: RenderSelectOptio
     }
   }
 
+  if (opts.showTabs) {
+    const tabs = list.tabList();
+    if (tabs.length > 1) {
+      const active = list.activeTab();
+      const bar = "  " + tabs.map(t => (t === active ? tint(`[${t}]`, chalk.cyan.bold) : tint(` ${t} `, chalk.gray))).join(" ");
+      out.push(cols ? clampToCols(bar, cols) : bar);
+    }
+  }
+
   const items = list.visible();
   if (items.length === 0) {
     const empty = tint("  (no matches)", chalk.gray);
@@ -208,7 +249,9 @@ export function renderSelectList<T>(list: SelectList<T>, opts: RenderSelectOptio
 
   const q = list.filter();
   const filterPart = q ? `filter: ${q}` : "type to filter";
-  const keys = unicode ? "\u2191/\u2193 move \u00b7 enter select \u00b7 esc cancel" : "up/down move . enter select . esc cancel";
+  const showTab = opts.showTabs && list.tabList().length > 1;
+  const tabHint = showTab ? (unicode ? " \u00b7 tab provider" : " . tab provider") : "";
+  const keys = (unicode ? "\u2191/\u2193 move \u00b7 enter select \u00b7 esc cancel" : "up/down move . enter select . esc cancel") + tabHint;
   const footer = tint(`  ${filterPart}  \u2014  ${keys}`, chalk.gray);
   out.push(cols ? clampToCols(footer, cols) : footer);
   return out;