jeo-code 0.7.16 → 0.7.18

package/src/commands/skills.ts

@@ -1,18 +1,9 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import * as os from "node:os";
-import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs, bundledSkillFileContent } from "../skills/catalog";
+import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs, bundledSkillFileContent, userSkillsDir } from "../skills/catalog";
 import { getLocalJeoDir } from "../agent/state";
-import { jeoEnv } from "../util/env";
-
-/** User-level bundled-skills install dir (`~/.jeo/skills`, honoring JEO_CONFIG_DIR /
- *  $HOME overrides) — the destination `jeo skills sync` reconciles against, matching
- *  the highest-precedence flat dir in {@link skillDirs}. */
-export function userSkillsDir(): string {
-  const userHome = process.env.HOME || os.homedir();
-  const home = jeoEnv("CONFIG_DIR") || path.join(userHome, ".jeo");
-  return path.join(home, "skills");
-}
+
+export { userSkillsDir };
 
 export type SkillSyncStatus = "missing" | "up-to-date" | "differs";
 export type SkillSyncAction = "installed" | "overwritten" | "preserved" | "unchanged" | "none";

package/src/prompts/agents/architect.md

@@ -11,6 +11,7 @@ Assess architecture, maintainability, correctness, and spec compliance with file
 - Prioritize spec/root-cause correctness before style comments.
 - Rate findings by severity: `CRITICAL`, `HIGH`, `MEDIUM`, `LOW`.
 - Never return `APPROVE` if CRITICAL/HIGH issues remain.
+- A clean verdict is not the absence of inspection: do not return `CLEAR`/`APPROVE` merely because no problem surfaced. Base the verdict on files and paths you concretely examined, and say which ones.
 </constraints>
 
 <execution_loop>
@@ -29,6 +30,7 @@ Assess architecture, maintainability, correctness, and spec compliance with file
 Your final `done.reason` MUST be markdown with these sections:
 - `Summary:`
 - `Findings:`
+- `Inspected:` the files/paths you actually examined (evidence for the verdict)
 - `Recommendations:`
 - `Architectural Status:` one of `CLEAR`, `WATCH`, `BLOCK`
 - `Code Review Recommendation:` one of `APPROVE`, `COMMENT`, `REQUEST CHANGES`

package/src/prompts/agents/critic.md

@@ -10,6 +10,7 @@ Decide whether a plan or approach is actionable before execution proceeds.
 - Read-only: never modify files.
 - Do not invent problems; reject only with concrete gaps.
 - Simulate representative tasks against inspected evidence before deciding.
+- Honesty cuts both ways: if you catch yourself softening a real, blocking gap into `[ITERATE]` just to avoid blocking, that softening is the signal the gap is real — name it. But never manufacture a block: when gaps are concrete yet fixable in-flight prefer `[ITERATE]` over `[REJECT]`, and return `[OKAY]` once the plan is genuinely actionable.
 </constraints>
 
 <execution_loop>

package/src/skills/catalog.ts

@@ -261,6 +261,15 @@ export function skillSlashAliases(skill: SkillDoc): string[] {
 }
 
 
+/** User-level bundled-skills install dir (`<config>/skills`, i.e. `~/.jeo/skills`
+ *  honoring JEO_CONFIG_DIR / $HOME) — the highest-precedence flat skill dir and the
+ *  destination `jeo skills sync` reconciles against. $HOME wins over os.homedir() so
+ *  tests/sandboxes that re-point HOME are honored (see {@link skillDirs}). */
+export function userSkillsDir(): string {
+  const userHome = process.env.HOME || os.homedir();
+  return path.join(jeoEnv("CONFIG_DIR") || path.join(userHome, ".jeo"), "skills");
+}
+
 /** Global + per-project skill-doc directories (user-configurable SKILL.md files).
  *  Ordered lowest → highest precedence (a later dir's skill overrides an earlier
  *  one with the same name): foreign-ecosystem roots first, jeo-native last.
@@ -283,7 +292,7 @@ export function skillDirs(cwd: string = process.cwd()): string[] {
     path.join(userHome, ".claude", "skills"),
     path.join(home, "agent", "skills"),
     path.join(userHome, ".agents", "skills"),
-    path.join(home, "skills"),
+    userSkillsDir(),
     path.join(cwd, ".claude", "skills"),
     path.join(cwd, ".agents", "skills"),
     path.join(cwd, ".jeo", "skills"),
@@ -512,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). */

package/src/util/file-attachment.ts

@@ -18,6 +18,54 @@ import type { ImageAttachment } from "../ai/types";
 
 const IMAGE_EXT_RE = /\.(?:png|jpe?g|gif|webp|bmp)$/i;
 
+
+/**
+ * Normalize the whitespace around every `[image #N]` tag to a single space:
+ *  - one space before a tag that follows other text (none at line start),
+ *  - one space after a tag that is followed by more text,
+ *  - any run of spaces/tabs collapsed to one, and the whole string trimmed.
+ *
+ * A tag at the very end keeps NO trailing space (callers that want the caret to sit
+ * past it add exactly one). Terminals pad a dragged-and-dropped path with their own
+ * spacing and the Ctrl+V insert adds a separator, so without this the caret parks
+ * several columns past the tag — the "input point looks pushed by a few spaces" bug.
+ * Idempotent: re-normalizing already-clean text is a no-op.
+ */
+export function normalizeImageTags(text: string): string {
+  return text
+    .replace(/[ \t]*(\[image #\d+\])[ \t]*/g, (m, tag: string, off: number, s: string) =>
+      (off > 0 ? " " : "") + tag + (off + m.length < s.length ? " " : ""),
+    )
+    .replace(/[ \t]{2,}/g, " ")
+    .trim();
+}
+
+/** Caret offset just past the `[image #n]` tag in `text` (and its single trailing
+ *  space when present); falls back to end-of-text when the tag is absent. */
+export function caretAfterTag(text: string, n: number): number {
+  const tag = `[image #${n}]`;
+  const idx = text.indexOf(tag);
+  if (idx < 0) return text.length;
+  let end = idx + tag.length;
+  if (text[end] === " ") end += 1; // sit after the separating space, not on it
+  return end;
+}
+
+/**
+ * Insert an `[image #n]` tag at `cursor` within `line` (the Ctrl+V clipboard-image
+ * path), normalizing surrounding whitespace so the tag is flanked by exactly one
+ * space. A tag landing at end-of-line gets one trailing space so the user can keep
+ * typing; the returned caret sits right after the tag (and that space).
+ */
+export function insertImageTag(line: string, cursor: number, n: number): { text: string; cursor: number } {
+  const at = Math.max(0, Math.min(cursor, line.length));
+  const tag = `[image #${n}]`;
+  let text = normalizeImageTags(line.slice(0, at) + tag + line.slice(at));
+  const idx = text.indexOf(tag);
+  if (idx >= 0 && idx + tag.length >= text.length) text += " "; // trailing space at EOL for typing
+  return { text, cursor: caretAfterTag(text, n) };
+}
+
 /** Detect an image media type from magic bytes, or null when the bytes are not a
  *  recognised image. Used as the authoritative check (extension only gates the
  *  candidate scan; the bytes decide). */
@@ -114,6 +162,10 @@ export interface AttachResult {
   text: string;
   /** The newly-read image attachments, in source order. */
   images: ImageAttachment[];
+  /** Caret offset to park after the swap: just past the trailing space of the LAST
+   *  inserted tag (so the live box places the cursor right after the attachment,
+   *  ready for the user's prompt). Equals `text.length` when nothing was attached. */
+  cursor: number;
 }
 
 /**
@@ -131,7 +183,7 @@ export async function attachImagePaths(
   read: FileReader = defaultReader,
 ): Promise<AttachResult> {
   const tokens = findImagePathTokens(text);
-  if (tokens.length === 0) return { text, images: [] };
+  if (tokens.length === 0) return { text, images: [], cursor: text.length };
 
   const reads = await Promise.all(
     tokens.map(async (t) => {
@@ -154,5 +206,9 @@ export async function attachImagePaths(
     n += 1;
   }
   out += text.slice(cursor);
-  return { text: out, images };
+  if (images.length === 0) return { text: out, images, cursor: out.length };
+  // Collapse the spacing terminals add around a dropped path so the swapped-in tag
+  // (and the caret parked after it) is not pushed several columns to the right.
+  const normalized = normalizeImageTags(out);
+  return { text: normalized, images, cursor: caretAfterTag(normalized, n - 1) };
 }