jeo-code 0.7.17 → 0.7.18

package/CHANGELOG.md

@@ -7,6 +7,21 @@ 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.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.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.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.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.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.18",
   "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, parseSkillSlashInvocation, 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,27 @@ 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 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).
   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",
+        });
+      }
+    }
+  }
 
   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,12 +1277,18 @@ 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.
     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);
@@ -2449,15 +2472,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 +2503,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;
+    }
+
+    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;
     }
-    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`);
+    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;
   };
 
@@ -4419,6 +4443,20 @@ 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,6 +521,20 @@ 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 };
+}
+
 export interface SkillInvocation {
   skill: SkillDoc;
   intent: string;

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

@@ -106,3 +106,43 @@ 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 });
 }
+
+/** 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/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). */