jeo-code 0.7.17 → 0.7.19

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.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._
+
+### Added
+- **Slash completion gains gjc §2.1 fuzzy name matching with a description fallback.** `src/tui/components/autocomplete.ts` adds pure `fuzzyMatch`/`fuzzyScore` (exact 100 > startsWith 80 > includes 60 > subsequence `40 − gaps×5`, min 1) and a `fuzzyCommandHits` ranker, so `/mdl` → `/model` now completes while prefix-exact behaviour (`/mod` → `/model`) is preserved. When nothing matches a command name, both the autocomplete dropdown and `matchSlash` (`slash.ts`) fall back to a description substring match — `/oauth` → `/login`, `/clipboard` → `/dump` — gated to ≥2-char queries with a real substring hit to avoid flooding. New `SLASH_COMMAND_DESCRIPTIONS` map backs the fallback.
+- **Resolved skills can contribute `/` slash commands, not just `$<name>`.** Every slash alias a resolved skill declares (frontmatter `aliases:`/`slash:`) becomes a real, dispatchable palette command grouped under "skills" — extending the slash menu, autocomplete, and previews. `runLaunchCommand` (`src/commands/launch.ts`) wires `skillSlashAliases`/`parseSkillSlashInvocation` so both the interactive REPL (`/obsidian-capture note`) and one-shot mode (`jeo "/obsidian-capture note"`) dispatch the owning skill, with built-in slash handlers always winning and first-declarer-wins alias scoping.
+- **`buildThinkingLevelChoices` extracts the reasoning menu (gjc `#renderThinkingMenu`).** `src/tui/components/live-model-picker.ts` adds `THINKING_LEVEL_ORDER` and a pure `buildThinkingLevelChoices(current, { inheritLabel, tokenHint })` that renders `<level> — <description> (<tokens>)` with the current level flagged and an optional leading `inherit` row for role targets — fully unit-testable.
+
+### Changed
+- **`/model` runs gjc's two-menu target → reasoning flow.** After a model is picked, `applyPickedModelWithTarget` now shows `applyTargetChoices` ("Set as DEFAULT / EXECUTOR / …", which target uses the model) followed by the per-target reasoning menu. DEFAULT updates the active session model and default thinking; a subagent role writes `~/.jeo/config.json` (model + thinking, or inherit) without switching the chat model. Replaces the prior default-only assignment.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 2009 pass / 0 fail across 234 files — including new `test/autocomplete.test.ts` cases (`fuzzyMatch` subsequence, `fuzzyScore` ranking, non-prefix subsequence completion, prefix-exact preservation, description-only fallback), `test/slash.test.ts` (`matchSlash` description fallback for intent queries), and `test/live-model-picker.test.ts` (`buildThinkingLevelChoices` ordering, token hints skipping minimal, `inherit` row only with a label, explicit role level outranking inherit).
+
 
 ## [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._

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.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.
-- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 
 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.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.
-- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 
 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.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.
-- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 
 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.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.
-- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

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, 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";
@@ -43,7 +43,7 @@ import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../ag
 import { listAliases } from "../ai/model-registry";
 import { openaiCompatDef, SUBSCRIPTION_PROVIDER_NAMES } from "../ai/providers/openai-compatible-catalog";
 
-import { allSubagentRoles, getSubagentRole, resolveSubagentModel, resolveSubagentMaxSteps, resolveSubagentThinking, parseMaxSteps, withSubagentSetting, clearSubagentSetting } from "../agent/subagents";
+import { allSubagentRoles, getSubagentRole, resolveSubagentModel, resolveSubagentMaxSteps, resolveSubagentThinking, parseMaxSteps, withSubagentSetting, clearSubagentSetting, applyTargetChoices } from "../agent/subagents";
 import { SelectList, renderSelectList, type SelectItem } from "../tui/components/select-list";
 import { SessionPicker, renderSessionPicker } from "../tui/components/session-picker";
 import {
@@ -57,7 +57,7 @@ import {
   formatPickListWithCapabilities,
   formatCapabilityLine,
 } from "../tui/components/config-panel";
-import { liveModelPicker, renderLiveModelPicker, type ModelAssignmentBadge } from "../tui/components/live-model-picker";
+import { liveModelPicker, renderLiveModelPicker, buildThinkingLevelChoices, type ModelAssignmentBadge } from "../tui/components/live-model-picker";
 
 import { loginPicker, renderLoginPicker, onboardingPicker, renderOnboardingPicker, apiKeyPicker, renderApiKeyPicker, subscriptionLoginPicker, type OnboardingAction } from "../tui/components/provider-picker";
 import { sanitizeForTerminal } from "../tui/components/code-view";
@@ -522,10 +522,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
   const workflowSkills = workflowSkillsForPrompt(resolvedSkills);
   const resolvedSkillNames = resolvedSkills.map(s => s.name);
-  // Skills are invoked ONLY via the `$<name>` entrypoint, never `/`. The `/` menu therefore
-  // advertises NO skill slash commands — keeping `skillSlashDetails` empty leaves the slash
-  // palette, autocomplete, and previews free of skill entries.
+  // 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[] = [];
+  // 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.";
@@ -1260,7 +1267,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
       return;
     }
-    // Slash / file-path / `/skill:` entrypoints (non-`$`) still resolve 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);
@@ -1460,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,
     };
@@ -2213,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();
@@ -2282,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);
@@ -2397,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;
@@ -2449,15 +2461,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     current: ThinkLevel | undefined,
     inheritLabel?: string,
   ): Promise<ThinkLevel | "inherit" | undefined> => {
-    const mark = (lvl: string): string => (current === lvl ? "current" : "");
-    const levels: { value: string; label: string; hint?: string }[] = [
-      ...(inheritLabel ? [{ value: "inherit", label: inheritLabel, hint: current === undefined ? "current" : "" }] : []),
-      { value: "minimal", label: "minimal — lightest reasoning", hint: mark("minimal") },
-      { value: "low", label: `low — light reasoning (~${Math.round(thinkingMaxTokens("low") / 1000)}k tokens)`, hint: mark("low") },
-      { value: "medium", label: `medium — moderate reasoning (~${Math.round(thinkingMaxTokens("medium") / 1000)}k tokens)`, hint: mark("medium") },
-      { value: "high", label: `high — deep reasoning (~${Math.round(thinkingMaxTokens("high") / 1000)}k tokens)`, hint: mark("high") },
-      { value: "xhigh", label: `xhigh — maximum reasoning (~${Math.round(thinkingMaxTokens("xhigh") / 1000)}k tokens)`, hint: mark("xhigh") },
-    ];
+    const levels = buildThinkingLevelChoices(current, {
+      inheritLabel,
+      tokenHint: lvl => (lvl === "minimal" ? undefined : `~${Math.round(thinkingMaxTokens(lvl as ThinkLevel) / 1000)}k tokens`),
+    });
     const picked = await pickFromOptions(title, levels);
     return picked === "inherit" || isThinkingLevel(picked) ? picked : undefined;
   };
@@ -2485,57 +2492,63 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     return leaf.replace(/^gpt/i, "GPT");
   };
 
-  const modelActionChoices = (config: Awaited<ReturnType<typeof readGlobalConfig>>): SelectItem<string>[] => {
-    const levels: ThinkLevel[] = ["minimal", "low", "medium", "high", "xhigh"];
-    const choices: SelectItem<string>[] = [];
-    const currentDefaultThinking = sessionThinking ?? config.thinkingLevel ?? "medium";
-    const appendChildren = (children: Array<Omit<SelectItem<string>, "depth" | "branch">>) => {
-      children.forEach((child, index) => {
-        choices.push({ ...child, depth: 1, branch: index === children.length - 1 ? "last" : "mid" });
-      });
-    };
-
-    choices.push({
-      value: "heading:default",
-      label: "Set as DEFAULT (Default)",
-      hint: `${config.defaultModel} (${currentDefaultThinking}) · roles → /agents`,
-      disabled: true,
-    });
-    appendChildren([
-      { value: "default:keep", label: "Set model only", hint: `keep thinking ${currentDefaultThinking}` },
-      ...levels.map(level => ({
-        value: `default:${level}`,
-        label: `thinking ${level}`,
-        hint: level === currentDefaultThinking ? "current" : `~${Math.round(thinkingMaxTokens(level) / 1000)}k tokens`,
-      })),
-    ]);
-
-    return choices;
-  };
-
-
-
-
+  // gajae-code `/model` parity: after a model is picked, the interactive flow
+  // runs TWO menus — gjc's `#renderActionMenu` ("Set as DEFAULT / EXECUTOR / …",
+  // i.e. WHICH target uses this model) followed by its `#renderThinkingMenu`
+  // ("Reasoning for <target>", the per-target reasoning budget). DEFAULT updates
+  // the active session model; a subagent role writes ~/.jeo/config.json without
+  // switching the chat model.
   const applyPickedModelWithTarget = async (target: string): Promise<boolean> => {
     if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
     const cfgForPick = await readGlobalConfig();
-    // `/model` only assigns the DEFAULT model + (optionally) the default thinking.
-    // Per-role model and thinking are configured in /agents (and /agents edit).
-    const choice = await pickFromOptions(`Model Name: ${displayModelName(target)}\n\nAction for: ${target}`, modelActionChoices(cfgForPick)) ?? "default:keep";
-    const [, action = "keep"] = choice.split(":", 2);
-    const { resolved, provider } = await describeModel(target);
-    const st = (await describeAllProviders(cfgForPick)).find(s => s.name === provider);
-    sessionModel = target;
-    await persistSessionModel();
-    const defaultThinking = isThinkingLevel(action) ? action : undefined;
-    if (defaultThinking) {
-      sessionThinking = defaultThinking;
+    const targetId = await pickFromOptions(
+      `Model Name: ${displayModelName(target)}\n\nAction for: ${target}`,
+      applyTargetChoices(cfgForPick).map(c => ({ value: c.value, label: c.label, hint: c.hint })),
+    );
+    if (!targetId) {
+      console.log("(cancelled)");
+      return true;
     }
-    await saveConfigPatch(raw => ({
-      ...rememberModelPatch(raw, target),
-      ...(defaultThinking ? { thinkingLevel: defaultThinking } : {}),
-    }));
-    console.log(`Model set to ${formatModelLine({ label: target, resolved, provider, ready: st?.ready })}${defaultThinking ? ` · thinking ${defaultThinking}` : ""} — saved as default. Role models/thinking: /agents`);
+
+    if (targetId === "default") {
+      const currentDefaultThinking = (sessionThinking ?? cfgForPick.thinkingLevel ?? "medium") as ThinkLevel;
+      const level = await pickThinkingLevel(`Reasoning for default: ${target}`, currentDefaultThinking);
+      if (level === undefined) {
+        console.log("(cancelled)");
+        return true;
+      }
+      const { resolved, provider } = await describeModel(target);
+      const st = (await describeAllProviders(cfgForPick)).find(s => s.name === provider);
+      sessionModel = target;
+      await persistSessionModel();
+      const defaultThinking = isThinkingLevel(level) ? level : undefined;
+      if (defaultThinking) {
+        sessionThinking = defaultThinking;
+      }
+      await saveConfigPatch(raw => ({
+        ...rememberModelPatch(raw, target),
+        ...(defaultThinking ? { thinkingLevel: defaultThinking } : {}),
+      }));
+      console.log(`Model set to ${formatModelLine({ label: target, resolved, provider, ready: st?.ready })}${defaultThinking ? ` · thinking ${defaultThinking}` : ""} — saved as default.`);
+      return true;
+    }
+
+    const role = getSubagentRole(targetId, cfgForPick);
+    if (!role) return false;
+    const currentRoleThinking = resolveSubagentThinking(role.id, cfgForPick) as ThinkLevel | undefined;
+    const level = await pickThinkingLevel(
+      `Reasoning for ${role.title}: ${target}`,
+      currentRoleThinking,
+      `inherit (default ${cfgForPick.thinkingLevel ?? "medium"})`,
+    );
+    if (level === undefined) {
+      console.log("(cancelled)");
+      return true;
+    }
+    const thinking = level === "inherit" ? undefined : (isThinkingLevel(level) ? level : undefined);
+    await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { model: target, thinking }) }));
+    const { provider } = await describeModel(target);
+    console.log(`${role.title} model set to ${target} (${provider})${level === "inherit" ? " · thinking inherits default" : ` · thinking ${level}`} — saved to ~/.jeo/config.json.`);
     return true;
   };
 
@@ -4383,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.
@@ -4419,6 +4424,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           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,23 +521,38 @@ export function getSkillBySlash(skills: SkillDoc[], command: string): SkillDoc |
   return skills.find(s => skillSlashAliases(s).some(a => a.toLowerCase() === q));
 }
 
+/** 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 {
   skill: SkillDoc;
   intent: string;
   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 };
     }
@@ -549,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,
@@ -567,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/autocomplete.ts

@@ -13,7 +13,7 @@
  * completer never blocks on the network. Static data (slash names, catalog ids,
  * provider names, role ids) is filled by `staticCompletionContext()`.
  */
-import { SLASH_COMMANDS } from "./slash";
+import { SLASH_COMMANDS, SLASH_COMMAND_DESCRIPTIONS } from "./slash";
 import { catalogIds } from "../../ai/model-catalog-compat";
 import { PROVIDER_NAMES } from "../../ai/provider-status";
 import { SUBAGENT_ROLES } from "../../agent/subagents";
@@ -84,6 +84,82 @@ function prefixHits(pool: string[], token: string): string[] {
   return pool.filter(c => c.toLowerCase().startsWith(q));
 }
 
+/**
+ * Fuzzy subsequence test (gjc parity): every char of `query` appears in
+ * `target` in order (not necessarily adjacent). Empty query matches everything.
+ */
+export function fuzzyMatch(query: string, target: string): boolean {
+  if (!query) return true;
+  let qi = 0;
+  for (let ti = 0; ti < target.length && qi < query.length; ti++) {
+    if (target[ti] === query[qi]) qi++;
+  }
+  return qi === query.length;
+}
+
+/**
+ * Score a match (gjc parity): exact=100 > startsWith=80 > includes=60 >
+ * subsequence(40 − gaps×5, min 1). Returns 0 when `query` is not a subsequence.
+ */
+export function fuzzyScore(query: string, target: string): number {
+  if (!query) return 80;
+  if (query === target) return 100;
+  if (target.startsWith(query)) return 80;
+  if (target.includes(query)) return 60;
+  let qi = 0;
+  let gaps = 0;
+  let lastMatch = -1;
+  for (let ti = 0; ti < target.length && qi < query.length; ti++) {
+    if (target[ti] === query[qi]) {
+      if (lastMatch !== -1 && ti !== lastMatch + 1) gaps++;
+      lastMatch = ti;
+      qi++;
+    }
+  }
+  if (qi < query.length) return 0;
+  return Math.max(1, 40 - gaps * 5);
+}
+
+/**
+ * Fuzzy command-name matches, ranked best-first (gjc §2.1): higher fuzzyScore
+ * first, ties broken by registration order so the list stays stable. Prefix
+ * matches always outrank looser subsequence hits, so `/mod`→`/model` is kept
+ * while `/mdl`→`/model` now also completes.
+ */
+function fuzzyHits(pool: string[], token: string): string[] {
+  const q = token.toLowerCase();
+  return pool
+    .map((c, index) => ({ c, score: fuzzyScore(q, c.toLowerCase()), index }))
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .map(x => x.c);
+}
+
+/**
+ * Command-name completion with a description fallback (gjc §2.1). Name matches
+ * win outright (so `/mod`→`/model` stays precise); only when NOTHING matches the
+ * name do we fall back to substring-or-better description hits, so intent-style
+ * queries with no literal name match still resolve — e.g. `/oauth`→`/login`,
+ * `/transcript`→`/dump`. The description fallback requires ≥2 query chars and a
+ * real substring (not a loose subsequence) to avoid flooding the dropdown.
+ */
+function fuzzyCommandHits(pool: string[], token: string): string[] {
+  const nameHits = fuzzyHits(pool, token);
+  if (nameHits.length > 0) return nameHits;
+
+  const q = token.replace(/^\//, "").toLowerCase();
+  if (q.length < 2) return [];
+  return pool
+    .map((c, index) => {
+      const desc = SLASH_COMMAND_DESCRIPTIONS.get(c);
+      const hit = desc?.includes(q) ?? false;
+      return { c, score: hit ? fuzzyScore(q, desc!) * 0.5 : 0, index };
+    })
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .map(x => x.c);
+}
+
 /** De-duplicate (case-insensitive, first wins), preserving order, capped. */
 function dedupeCap(items: string[], cap = MAX_COMPLETIONS): string[] {
   const seen = new Set<string>();
@@ -129,7 +205,7 @@ export function complete(line: string, ctx: CompletionContext): CompletionResult
     // `/command` mention completion mid-line (the leading-token case is the
     // dedicated command branch below, which also completes arguments).
     if (token.startsWith("/")) {
-      return { completions: dedupeCap(prefixHits(ctx.slashCommands, token)), token, kind: "command" };
+      return { completions: dedupeCap(fuzzyCommandHits(ctx.slashCommands, token)), token, kind: "command" };
     }
     return { completions: [], token: line, kind: "none" };
   }
@@ -137,7 +213,7 @@ export function complete(line: string, ctx: CompletionContext): CompletionResult
   // Completing the command name itself (single token, still typing it).
   if (tokens.length <= 1 && !trailingSpace) {
     const token = tokens[0] ?? "/";
-    return { completions: dedupeCap(prefixHits(ctx.slashCommands, token)), token, kind: "command" };
+    return { completions: dedupeCap(fuzzyCommandHits(ctx.slashCommands, token)), token, kind: "command" };
   }
 
   const cmd = tokens[0]!.toLowerCase();

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

@@ -104,5 +104,45 @@ 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. */
+export const THINKING_LEVEL_ORDER = ["minimal", "low", "medium", "high", "xhigh"] as const;
+
+const THINKING_LEVEL_DESCRIPTION: Record<string, string> = {
+  minimal: "lightest reasoning",
+  low: "light reasoning",
+  medium: "moderate reasoning",
+  high: "deep reasoning",
+  xhigh: "maximum reasoning",
+};
+
+export interface ThinkingLevelChoiceOptions {
+  /** Prepend an "inherit" row (role targets only, which can follow the default). */
+  inheritLabel?: string;
+  /** Per-level reasoning-budget hint, e.g. "~32k tokens". Return undefined to omit. */
+  tokenHint?: (level: string) => string | undefined;
+}
+
+/**
+ * gajae-code-parity reasoning menu (gjc's `#renderThinkingMenu`): the per-target
+ * "Reasoning for …" choices shown after a model is picked. Each level renders as
+ * `<level> — <description> (<tokens>)` with the current level flagged. Role
+ * targets gain a leading `inherit` row. Pure — fully unit-testable.
+ */
+export function buildThinkingLevelChoices(
+  current: string | undefined,
+  opts: ThinkingLevelChoiceOptions = {},
+): SelectItem<string>[] {
+  const items: SelectItem<string>[] = [];
+  if (opts.inheritLabel) {
+    items.push({ value: "inherit", label: opts.inheritLabel, hint: current === undefined ? "current" : "" });
+  }
+  for (const level of THINKING_LEVEL_ORDER) {
+    const tokens = opts.tokenHint?.(level);
+    const label = `${level} — ${THINKING_LEVEL_DESCRIPTION[level]}${tokens ? ` (${tokens})` : ""}`;
+    items.push({ value: level, label, hint: current === level ? "current" : "" });
+  }
+  return items;
+}

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;

package/src/tui/components/slash.ts

@@ -65,6 +65,11 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
 
 export const SLASH_COMMANDS = SLASH_COMMAND_DETAILS.map(c => c.command);
 
+/** Bundled command name → lowercased description (gjc §2.1 description matching). */
+export const SLASH_COMMAND_DESCRIPTIONS = new Map<string, string>(
+  SLASH_COMMAND_DETAILS.map(c => [c.command, c.description.toLowerCase()]),
+);
+
 export function mergeSlashCommandDetails(extra: readonly SlashCommandInfo[] = []): SlashCommandInfo[] {
   const byCommand = new Map<string, SlashCommandInfo>();
   for (const d of [...SLASH_COMMAND_DETAILS, ...extra]) byCommand.set(d.command, d);
@@ -73,8 +78,10 @@ export function mergeSlashCommandDetails(extra: readonly SlashCommandInfo[] = []
 
 /** Return the slash commands that match `input` (case-insensitive). Prefix matches
  *  come first; a fuzzy subsequence fallback (gjc-style, e.g. `/expt` → `/export`)
- *  follows so typos / abbreviations still surface a command. A bare `/` lists every
- *  command. Empty for non-slash input. */
+ *  follows so typos / abbreviations still surface a command. When NOTHING matches
+ *  the name, fall back to a description substring match (gjc §2.1) so intent-style
+ *  queries with no literal name match still resolve — e.g. `/oauth` → `/login`,
+ *  `/clipboard` → `/dump`. A bare `/` lists every command. Empty for non-slash input. */
 export function matchSlash(input: string, commands: string[] = SLASH_COMMANDS): string[] {
   if (!input.startsWith("/")) return [];
   const q = input.toLowerCase();
@@ -82,7 +89,12 @@ export function matchSlash(input: string, commands: string[] = SLASH_COMMANDS):
   if (body === "") return [...commands];
   const starts = commands.filter(c => c.toLowerCase().startsWith(q));
   const fuzzy = commands.filter(c => !starts.includes(c) && subsequence(body, c.slice(1).toLowerCase()));
-  return [...starts, ...fuzzy];
+  const named = [...starts, ...fuzzy];
+  if (named.length > 0) return named;
+  // Description fallback: only when no name matches, and only for queries of ≥2
+  // chars with a real substring hit (not a loose subsequence), to avoid flooding.
+  if (body.length < 2) return [];
+  return commands.filter(c => SLASH_COMMAND_DESCRIPTIONS.get(c)?.includes(body) ?? false);
 }
 
 /** True when `input` looks like a slash command (starts with "/" and has no space). */