jeo-code 0.7.16 → 0.7.18

package/src/agent/memory.ts

@@ -202,6 +202,10 @@ export interface Concept {
   tags: string[];
   /** high | medium | low — distiller defaults to "high"; drives core selection. */
   confidence: string;
+  /** Load-bearing invariant (frontmatter `pinned: true`): selected into the injection
+   *  budget BEFORE any query/recency fill, so the cap can never evict it (philosophy
+   *  synthesis R8 / consensus #3 — pinned invariants survive on a reserved budget). */
+  pinned: boolean;
   /** Bundle-relative path, e.g. `commands/bun-test.md`. */
   relPath: string;
 }
@@ -284,6 +288,7 @@ async function loadConceptsFromBundle(bundleDir: string): Promise<Concept[]> {
       body: parsed.body.trim(),
       tags: Array.isArray(fm.tags) ? fm.tags.filter((t): t is string => typeof t === "string") : [],
       confidence: typeof fm.confidence === "string" ? fm.confidence : "high",
+      pinned: fm.pinned === true,
       relPath,
     };
     cacheParsedConcept(file, sig, concept);
@@ -339,10 +344,16 @@ export function searchConcepts(concepts: Concept[], query: string): { concept: C
     .sort((a, b) => b.score - a.score);
 }
 
-/** Priority order for injection: high-confidence "core" concepts first, then by
- *  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. */
+/** 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. */
 function priorityOrder(concepts: Concept[], query?: string): Concept[] {
   const tokens = tokenize(query);
   // 1-hop graph expansion: seed from concepts the query directly hits, then mark
@@ -354,14 +365,22 @@ function priorityOrder(concepts: Concept[], query?: string): Concept[] {
     for (const id of expandByGraph(seeds, graph, 1)) related.add(id);
   }
   return concepts
-    .map((concept, i) => ({
-      concept,
-      i,
-      core: concept.confidence === "high",
-      score: scoreConcept(concept, tokens),
-      related: related.has(conceptId(concept.relPath)),
-    }))
+    .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)),
+      };
+    })
     .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;
@@ -404,14 +423,22 @@ function renderConcepts(concepts: Concept[]): string {
 
 /** Greedily select concepts (in priority order) whose grouped render stays within
  *  `budget` chars, dropping the lowest-priority concepts first. At least the
- *  top-priority concept is always kept (the framing/backstop cap still applies). */
+ *  top-priority concept is always kept (the framing/backstop cap still applies).
+ *
+ *  Pinned (load-bearing) invariants get a RESERVED budget: they are selected FIRST,
+ *  before any query/recency fill, so a tight cap can never evict an invariant the
+ *  gates depend on (philosophy-synthesis consensus #3). The remaining budget then
+ *  holds the failure-first / core / query-relevant fill. */
 function selectWithinBudget(concepts: Concept[], query: string | undefined, budget: number): Concept[] {
-  const ordered = priorityOrder(concepts, query);
   const selected: Concept[] = [];
-  for (const c of ordered) {
-    if (renderConcepts([...selected, c]).length <= budget) selected.push(c);
-  }
-  if (selected.length === 0 && ordered.length > 0) selected.push(ordered[0]!);
+  const take = (pool: Concept[]) => {
+    for (const c of priorityOrder(pool, query)) {
+      if (renderConcepts([...selected, c]).length <= budget) selected.push(c);
+    }
+  };
+  take(concepts.filter(c => c.pinned)); // reserved budget: invariants survive the cap
+  take(concepts.filter(c => !c.pinned)); // recency/query fill in the remaining budget
+  if (selected.length === 0 && concepts.length > 0) selected.push(priorityOrder(concepts, query)[0]!);
   return selected;
 }
 
@@ -610,6 +637,55 @@ async function cleanupStalePendingFiles(dir: string): Promise<void> {
   }
 }
 
+/** Upsert ONE concept document into the bundle: resolve its file (dedup by title —
+ *  same title overwrites in place, a colliding slug gets a numeric suffix), merge
+ *  over any existing frontmatter, and atomically write it. The single source of
+ *  truth for a concept file's on-disk shape — shared by the session-exit distiller
+ *  and the deterministic recordFailedAttempt path. Does NOT touch index/log (callers
+ *  batch that). Assumes a non-empty title; unknown types fall back to facts/. */
+async function upsertConceptFile(
+  bundleDir: string,
+  c: { type: string; title: string; description?: string; body?: string; tags?: string[]; confidence?: string; links?: string[]; pinned?: boolean },
+): Promise<string> {
+  const dir = DIR_BY_TYPE[c.type] ?? "facts";
+  await fs.mkdir(path.join(bundleDir, dir), { recursive: true });
+  let slug = slugify(c.title);
+  let relPath = `${dir}/${slug}.md`;
+  let fullPath = path.join(bundleDir, relPath);
+  let suffix = 1;
+  while (true) {
+    try {
+      if ((parseConcept(await fs.readFile(fullPath, "utf-8")).frontmatter.title || "") === c.title) break;
+      slug = `${slugify(c.title)}-${suffix}`;
+      relPath = `${dir}/${slug}.md`;
+      fullPath = path.join(bundleDir, relPath);
+      suffix++;
+    } catch {
+      break;
+    }
+  }
+  let existingFm: Record<string, unknown> = {};
+  try {
+    existingFm = parseConcept(await fs.readFile(fullPath, "utf-8")).frontmatter as Record<string, unknown>;
+  } catch {}
+  const frontmatter = {
+    ...existingFm,
+    type: c.type,
+    title: c.title,
+    description: c.description ?? "",
+    tags: c.tags ?? [],
+    timestamp: new Date().toISOString(),
+    confidence: c.confidence ?? "high",
+    last_verified: new Date().toISOString().split("T")[0],
+    links: c.links ?? [],
+    ...(c.pinned ? { pinned: true } : {}),
+  };
+  const tmpPath = `${fullPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmpPath, serializeConcept(frontmatter, c.body ?? ""), "utf-8");
+  await fs.rename(tmpPath, fullPath);
+  return relPath;
+}
+
 export async function distillSessionMemory(
   history: Message[],
   cwd: string,
@@ -721,57 +797,15 @@ export async function distillSessionMemory(
         const title = typeof concept.title === "string" ? concept.title.trim() : "";
         if (!type || !title) continue;
         try {
-          // Unknown types fall back to facts/ (lenient — OKF tolerates extra types).
-          const dir = DIR_BY_TYPE[type] ?? "facts";
-
-          const targetDir = path.join(bundleDir, dir);
-          await fs.mkdir(targetDir, { recursive: true });
-
-          let slug = slugify(title);
-          let relPath = `${dir}/${slug}.md`;
-          let fullPath = path.join(bundleDir, relPath);
-
-          let suffix = 1;
-          while (true) {
-            try {
-              const existingContent = await fs.readFile(fullPath, "utf-8");
-              const parsed = parseConcept(existingContent);
-              const existingTitle = parsed.frontmatter.title || "";
-              if (existingTitle === title) {
-                break;
-              }
-              slug = `${slugify(title)}-${suffix}`;
-              relPath = `${dir}/${slug}.md`;
-              fullPath = path.join(bundleDir, relPath);
-              suffix++;
-            } catch {
-              break;
-            }
-          }
-
-          let existingFm = {};
-          try {
-            const existingContent = await fs.readFile(fullPath, "utf-8");
-            existingFm = parseConcept(existingContent).frontmatter;
-          } catch {}
-
-          const frontmatter = {
-            ...existingFm,
-            type,
+          await upsertConceptFile(bundleDir, {
+            type, // unknown types fall back to facts/ inside the helper (lenient)
             title,
             description: typeof concept.description === "string" ? concept.description : "",
+            body: typeof concept.body === "string" ? concept.body : "",
             tags: Array.isArray(concept.tags) ? concept.tags.filter((t): t is string => typeof t === "string") : [],
-            timestamp: new Date().toISOString(),
             confidence: typeof concept.confidence === "string" ? concept.confidence : "high",
-            last_verified: new Date().toISOString().split("T")[0],
             links: Array.isArray(concept.links) ? concept.links.filter((l): l is string => typeof l === "string") : [],
-          };
-
-          const serialized = serializeConcept(frontmatter, typeof concept.body === "string" ? concept.body : "");
-          const tmpPath = `${fullPath}.tmp-${process.pid}`;
-          await fs.writeFile(tmpPath, serialized, "utf-8");
-          await fs.rename(tmpPath, fullPath);
-
+          });
           updatedConcepts.push({ title, type });
         } catch {
           // Skip just this concept; keep distilling the rest of the batch.
@@ -819,6 +853,46 @@ export async function distillSessionMemory(
   }
 }
 
+/** Mid-session, deterministic (no-LLM) capture of a dead end into the OKF bundle.
+ *  The session-exit distill only learns AFTER a session ends; a turn that stalled
+ *  (consecutive-failure / cycle / repeat guard fired) is a dead end the *next turn
+ *  of the SAME session* should already avoid. This writes ONE FailedAttempt concept
+ *  immediately so the per-turn memory injection resurfaces it (priorityOrder puts a
+ *  query-relevant FailedAttempt first), closing the loop the user described: each
+ *  iteration gets sharper by building on accumulated failure knowledge. Confidence
+ *  is "medium" (not "high") so it never enters the always-injected "core" tier — it
+ *  only surfaces when the query actually hits it, and the richer session-exit distill
+ *  later consolidates or replaces it. Best-effort: a write failure is swallowed. */
+export async function recordFailedAttempt(
+  cwd: string,
+  attempt: { title: string; description?: string; body?: string; tags?: string[] },
+): Promise<{ recorded: boolean; skipped?: string }> {
+  if (jeoEnv("NO_MEMORY") === "1") return { recorded: false, skipped: "disabled (JEO_NO_MEMORY=1)" };
+  const title = attempt.title?.trim();
+  if (!title) return { recorded: false, skipped: "empty title" };
+  try {
+    const bundleDir = path.join(cwd, ".jeo", "memory");
+    // confidence "medium" keeps it out of the always-injected core tier (priorityOrder)
+    // — it only surfaces when the query actually hits it.
+    await upsertConceptFile(bundleDir, {
+      type: "FailedAttempt",
+      title,
+      description: attempt.description ?? "",
+      body: attempt.body ?? "",
+      tags: Array.isArray(attempt.tags) ? attempt.tags.filter(t => typeof t === "string") : [],
+      confidence: "medium",
+    });
+    await withIndexLock(bundleDir, async () => {
+      await rebuildIndex(bundleDir);
+      await updateLog(bundleDir, [{ title, type: "FailedAttempt" }]);
+    });
+    invalidateConceptCache();
+    return { recorded: true };
+  } catch (err: any) {
+    return { recorded: false, skipped: `record failed: ${err?.message ?? String(err)}` };
+  }
+}
+
 
 
 // ── Detached background distillation (round-16) ──

package/src/commands/deep-interview.ts

@@ -497,7 +497,9 @@ export async function runDeepInterviewEngine(opts: DeepInterviewEngineOptions =
           `  "constraints": ["Optional list of constraints once ambiguity is <= ${threshold}"],\n` +
           `  "acceptance_criteria": ["Concrete, testable acceptance criteria required before the seed can freeze"]\n` +
           `}\n` +
-          `Ensure ambiguityScore drops dynamically as more detail is gathered. Do not report ambiguityScore <= ${threshold} unless acceptance_criteria is populated with concrete, testable checks.`
+          `Ensure ambiguityScore drops dynamically as more detail is gathered. Do not report ambiguityScore <= ${threshold} unless acceptance_criteria is populated with concrete, testable checks.\n` +
+          `Do not fill an ambiguous point with your own convenient assumption to push the score down — surface that assumption as the nextQuestion instead. Never supply unstated detail that makes the request look simpler or safer than the user actually wrote it.\n` +
+          `Conversely, when the user's answers genuinely resolve a dimension, lower the score accordingly — do not keep a dimension ambiguous just to prolong the interview. If you notice yourself quietly narrowing the user's idea to make it easier to score, that narrowing is the signal the dimension is still open: ask, don't assume.`
       },
       {
         role: "user",

package/src/commands/launch.ts

@@ -4,7 +4,7 @@ import { PassThrough } from "node:stream";
 import { runAgentLoop, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKING_DISCIPLINE, OUTPUT_DISCIPLINE, VERIFICATION_DIRECTIVE, type AgentLoopEvents } from "../agent/engine";
 import { createOpikTracer, wrapEvents } from "../agent/opik-tracer";
 import { initialDynamicStepLimit } from "../agent/step-budget";
-import { memoryPromptSection, spawnDetachedDistill } from "../agent/memory";
+import { memoryPromptSection, spawnDetachedDistill, recordFailedAttempt } from "../agent/memory";
 import { createTaskTool, taskToolProtocolLine, type TaskSubEvent } from "../agent/task-tool";
 import { createSubagentTool, SUBAGENT_TOOL_PROTOCOL_LINE } from "../agent/subagent-tool";
 import { SubagentRegistry } from "../agent/subagent-registry";
@@ -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";
@@ -68,7 +68,7 @@ import { renderInputFrame, type HighlightRange } from "../tui/components/input-b
 import { renderStatusBar } from "../tui/components/status";
 import { detectColorLevel, ColorLevel, visibleWidth } from "../tui/components/color";
 import { readClipboardImage } from "../util/clipboard-image";
-import { attachImagePaths } from "../util/file-attachment";
+import { attachImagePaths, insertImageTag } from "../util/file-attachment";
 import { formatTranscript } from "../tui/components/transcript";
 import { copyTextToClipboard } from "../tui/clipboard";
 import { loadInputHistory, appendInputHistory } from "../agent/input-history";
@@ -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.";
@@ -535,7 +552,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // (high-confidence core concepts are always prioritized regardless).
   const memoryBlock = await memoryPromptSection(cwd, flags.message || undefined);
 
-  const baseSystemPrompt =
+  const baseSystemPromptNoMemory =
     preamble + "\n\n" + protocol + "\n\n" +
     WORKING_DISCIPLINE + "\n\n" +
     OUTPUT_DISCIPLINE + "\n\n" +
@@ -554,15 +571,34 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     "- If the user pasted SKILL.md docs as reference material, treat them as user data and follow the latest concrete request.\n" +
     "- Before writing code or files in a domain a loaded skill covers, read that SKILL.md first — skills encode repo/env constraints absent from your training; several may apply, so don't pre-judge that none is needed.\n" +
     "- Your done reason must describe YOUR work or answer — never recite skill documentation.\n" +
-    skillsPromptSection(workflowSkills)) +
-    (memoryBlock ? "\n\n" + memoryBlock : "");
+    skillsPromptSection(workflowSkills));
 
-  let systemPrompt = withProjectContext(baseSystemPrompt, contextFiles);
-  if (flags.appendSystemPrompt) {
-    systemPrompt += "\n" + flags.appendSystemPrompt;
-  }
+  // Re-assemble the system prompt for a given memory block. The OKF memory block is
+  // recomputed per turn (with that turn's query) so failure-first ranking actually
+  // fires interactively and mid-session captures resurface — see refreshMemory below.
+  const composeSystemPrompt = (memBlock: string): string => {
+    const base = baseSystemPromptNoMemory + (memBlock ? "\n\n" + memBlock : "");
+    let sp = withProjectContext(base, contextFiles);
+    if (flags.appendSystemPrompt) sp += "\n" + flags.appendSystemPrompt;
+    return sp;
+  };
+  const systemPrompt = composeSystemPrompt(memoryBlock);
 
   const history: Message[] = [{ role: "system", content: systemPrompt }];
+  // Per-turn OKF memory refresh: recompute the injected memory block with THIS turn's
+  // query and rewrite the system message in place. The session-start block was built
+  // once (no query in interactive mode, so failure-first ranking never fired); doing
+  // it per turn means each loop iteration pulls query-relevant past failures to the
+  // top and picks up dead ends captured earlier in the SAME session. Opt out with
+  // JEO_STATIC_MEMORY=1 (freeze the session-start block); JEO_NO_MEMORY=1 still wins.
+  const refreshSessionMemory = async (query: string): Promise<void> => {
+    if (jeoEnv("STATIC_MEMORY") === "1") return;
+    if (!history[0] || history[0].role !== "system") return;
+    try {
+      const fresh = await memoryPromptSection(cwd, query || undefined);
+      history[0] = { ...history[0], content: composeSystemPrompt(fresh) };
+    } catch { /* keep the prior system prompt on any failure */ }
+  };
   let sessionModel: string | undefined = initialSessionModel;
   // Session thinking-level override (`/thinking`); falls back to the config level.
   let sessionThinking: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined = flags.thinking ?? cfg.thinkingLevel;
@@ -764,6 +800,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         interactiveTurnActive = true;
         tui.start();
       }
+      // Refresh injected OKF memory with THIS turn's query before the model call so
+      // failure-first ranking fires and same-session dead ends resurface.
+      await refreshSessionMemory(userInput);
       const compRes = await maybeCompact(history, {
         model: activeModel,
         contextTokens,
@@ -1062,6 +1101,30 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       sessionUsage.outputTokens += result.usage.outputTokens;
     }
     sessionUsage.turns++;
+
+    // Mid-session failure capture: a guard-detected stall (the model repeated /
+    // cycled / consecutively failed without recovering) is a dead end the rest of
+    // THIS session should avoid. Record it into OKF now (deterministic, no LLM) so
+    // the next turn's memory refresh resurfaces it. Best-effort; never blocks the turn.
+    if (result.stopClass) {
+      const task = userInput.replace(/\s+/g, " ").trim();
+      const excerpt = task.length > 70 ? task.slice(0, 70) + "…" : task;
+      const why = result.stopClass === "consecutive_failure"
+        ? "consecutive failing tool calls"
+        : result.stopClass === "cycle"
+          ? "cycling through the same tool calls"
+          : "repeating the same tool call";
+      const tags = Array.from(new Set(
+        task.toLowerCase().match(/[a-z0-9][a-z0-9_-]{3,}/g) ?? [],
+      )).slice(0, 8);
+      void recordFailedAttempt(cwd, {
+        title: `Stalled on: ${excerpt}`,
+        description: `A prior turn stalled (${why}) on this task — change approach before retrying.`,
+        body: `Task: ${task.slice(0, 240)}\n\nThe agent gave up after ${why} (${result.steps} steps) and could not recover. ` +
+          `Do NOT repeat the same line of attack; try a different decomposition, tool, or verification path.`,
+        tags,
+      }).catch(() => {});
+    }
     const usage = result.usage ? `  (${result.usage.inputTokens} in / ${result.usage.outputTokens} out tokens)` : "";
 
     if (turnConfig.gitAutoCommit) {
@@ -1214,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);
@@ -2403,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;
   };
@@ -2439,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;
     }
-    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;
   };
 
@@ -2671,7 +2741,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               if (dropped.images.length === 0 || dropped.text === before) return;
               pendingImages.push(...dropped.images);
               rli.line = dropped.text;
-              rli.cursor = dropped.text.length; // drop lands at the caret (line end in the common case)
+              rli.cursor = dropped.cursor; // park right after the swapped-in tag (whitespace normalized)
               typedLine = dropped.text;
               // Keep readline's internal screen model in step with the swapped-in tag so
               // the caret is not offset on the next keystroke (mirrors the Ctrl+V path).
@@ -2736,12 +2806,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             const img = await readClipboardImage();
             if (!img) return;
             pendingImages.push(img);
-            const tag = `[image #${pendingImages.length}]`;
             const rli = rl as unknown as { line: string; cursor: number; _refreshLine?: () => void };
             const at = typeof rli.cursor === "number" ? rli.cursor : rli.line.length;
-            const sep = rli.line.length > 0 && at > 0 && rli.line[at - 1] !== " " ? " " : "";
-            rli.line = rli.line.slice(0, at) + sep + tag + " " + rli.line.slice(at);
-            rli.cursor = at + sep.length + tag.length + 1;
+            // Insert the [image #N] tag at the caret with normalized single-space
+            // padding (shared with the drag-drop path) so the caret lands right after
+            // the tag instead of being pushed several columns by stray spaces.
+            const ins = insertImageTag(rli.line, at, pendingImages.length);
+            rli.line = ins.text;
+            rli.cursor = ins.cursor;
             typedLine = rli.line;
             // Sync readline's internal screen model to the injected tag (same as the
             // slash/tab completion accept paths): without it readline's stale row/cursor
@@ -4371,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]);