jeo-code 0.12.22 → 0.12.24

package/src/agent/state.ts

@@ -37,14 +37,24 @@ export interface StoredOAuth {
   projectId?: string;
 }
 
+/**
+ * Hook events. `pre-tool`/`post-turn`/`post-implementation` are the original tool-loop
+ * events. `pre-prompt` (Claude `UserPromptSubmit`) runs once per real user prompt before
+ * the model sees it and may inject context; `turn-end` (Claude `Stop`) runs once per
+ * completed turn with the final reply.
+ */
+export type HookEvent = "pre-tool" | "post-turn" | "post-implementation" | "pre-prompt" | "turn-end";
+
+export interface HookEntry {
+  event: HookEvent;
+  match?: { tool?: string };
+  run: string;
+  timeoutMs?: number;
+}
+
 export interface HookConfig {
   enabled?: boolean;
-  hooks?: Array<{
-    event: "pre-tool" | "post-turn" | "post-implementation";
-    match?: { tool?: string };
-    run: string;
-    timeoutMs?: number;
-  }>;
+  hooks?: HookEntry[];
 }
 
 export interface Config {
@@ -279,6 +289,17 @@ function globalConfigPath(): string {
   return path.join(globalConfigDir(), "config.json");
 }
 
+/**
+ * User-level hook registry, `<config dir>/hooks.json`. Same shape as a project's
+ * `.jeo/hooks.json` (`{ enabled?, hooks: [...] }`). It is deliberately separate from
+ * `config.json`: installers (jeo-skills' prompt-routing / knowledge-pipeline hooks)
+ * can own this one small file without touching credentials, and a schema-invalid
+ * `config.json` (which jeo resets wholesale) can never take their hooks down with it.
+ */
+export function userHooksPath(): string {
+  return path.join(globalConfigDir(), "hooks.json");
+}
+
 /**
  * Expand and absolutize a wiki-root path: a leading `~` becomes the home directory
  * and the result is `path.resolve`d so tools/hooks never see an un-expanded `~` or a

package/src/commands/doctor.ts

@@ -1,4 +1,5 @@
 import { readGlobalConfig } from "../agent/state";
+import { describeHooks, type HookReport } from "../agent/hooks";
 import { findRetiredPins } from "../ai/model-retirements";
 import { resolveCredential, snapshotProvider, type AuthProvider, type Credential } from "../auth";
 import { resolveProvider, describeProvider } from "../ai";
@@ -308,6 +309,28 @@ function sharedInstallLines(report: SharedInstallReport): string[] {
   return lines;
 }
 
+/** Human lines for the hook setup. Silent when nothing is configured and nothing is wrong. */
+function hookLines(report: HookReport | { error: string }): string[] {
+  if ("error" in report) return [chalk.yellow(`[hooks] check failed (${report.error})`)];
+  const { gate, registry, project, active, total } = report;
+  const lines: string[] = [];
+  if (gate === "off") lines.push(chalk.yellow("[hooks] disabled globally (config.json hooks.enabled=false): no hook runs, the registry included."));
+  if (project.state === "disabled") lines.push(chalk.yellow(`[hooks] ${project.path} sets enabled:false: no hook runs in this project.`));
+  for (const file of [registry, project]) {
+    if (file.state === "unreadable") lines.push(chalk.yellow(`[hooks] ${file.path} is not readable JSON: its hooks are ignored.`));
+    if (file.invalid > 0) lines.push(chalk.yellow(`[hooks] ${file.path}: ${file.invalid} invalid entr${file.invalid === 1 ? "y" : "ies"} ignored (unknown event, missing run, or bad timeoutMs).`));
+  }
+  if (project.state === "ok" && project.entries > 0 && gate !== "on") {
+    lines.push(chalk.yellow(`[hooks] ${project.path} lists ${project.entries} hook(s) that do not run: project hooks need hooks.enabled=true in config.json.`));
+  }
+  if (total > 0) {
+    const parts = Object.entries(active).map(([event, count]) => `${event} ${count}`).join(", ");
+    lines.push(`${chalk.green("[hooks]")} ${total} active (${parts})${registry.state === "ok" ? `; registry ${registry.path}` : ""}`);
+  }
+  if (lines.length > 0) lines.push("");
+  return lines;
+}
+
 export async function runDoctorCommand(args: string[] = [], deps: DoctorDeps = {}): Promise<void> {
   const strict = args.includes("--strict");
   const json = args.includes("--json");
@@ -476,6 +499,14 @@ export async function runDoctorCommand(args: string[] = [], deps: DoctorDeps = {
     sharedInstall = { error: err instanceof Error ? err.message : String(err) };
   }
 
+  // Hook setup: read-only, never affects `ready` or the exit code.
+  let hooks: HookReport | { error: string };
+  try {
+    hooks = await describeHooks(process.cwd());
+  } catch (err) {
+    hooks = { error: err instanceof Error ? err.message : String(err) };
+  }
+
   // --- JSON output mode (CI / scripting) ---
   if (json) {
     const report = {
@@ -498,6 +529,7 @@ export async function runDoctorCommand(args: string[] = [], deps: DoctorDeps = {
       })),
       oauth: oauthHealth,
       ready,
+      hooks,
       ...(routingEnabled ? { routing: { enabled: true, smolConfigured, preview: routingPreview, ...(routingNotes.length ? { notes: routingNotes } : {}) } } : {}),
       sharedInstall,
 
@@ -595,6 +627,8 @@ export async function runDoctorCommand(args: string[] = [], deps: DoctorDeps = {
   }
   console.log("");
 
+  for (const line of hookLines(hooks)) console.log(line);
+
   // Final verdict
   if (ready) {
     console.log(`${chalk.green("[READY]")} Default model '${config.defaultModel}' is reachable.`);

package/src/commands/launch.ts

@@ -57,7 +57,7 @@ import { callLlm, type Message } from "../agent/loop";
 import { friendlyProviderError } from "../util/provider-error";
 import { readGlobalConfig, saveConfigPatch, resolveWikiRoot } from "../agent/state";
 import { AgyCliError, type AgyTurnResult } from "../agent/antigravity-cli";
-import { currentSandboxExecution, withSandboxExecution, runPreToolHooks, runPostTurnHooks } from "../agent/hooks";
+import { currentSandboxExecution, withSandboxExecution, runPreToolHooks, runPostTurnHooks, runPrePromptHooks, runTurnEndHooks, setHookSessionId } from "../agent/hooks";
 import { createSandboxSupervisor } from "../agent/sandbox/supervisor";
 import { createSandboxPolicy } from "../agent/sandbox/policy";
 import { createGrantAuthority, ensurePrivateSandboxDirectory } from "../agent/sandbox/authority";
@@ -812,7 +812,7 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
     "- 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));
+    skillsPromptSection(workflowSkills, flags.message || undefined));
 
   // 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
@@ -1232,6 +1232,7 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
   ): Promise<{ done: boolean; steps: number; reply: string; rendered: boolean; usage: string; unverified: boolean }> => {
     opts?.signal?.throwIfAborted();
     if (currentSandboxExecution() && sessionId !== sandboxTranscriptId) throw new Error("SESSION_MISMATCH: start a new launch for the selected transcript; sandbox grants cannot cross sessions");
+    setHookSessionId(sessionId);
     let busyDraftHasPaste = false;
     const captureLiveInput = (chunk: string, view: LaunchTui | null): { captured: boolean; submittedEnter: boolean; handled: boolean } => {
       if (!queueBusyInput || !queueBusySnapshot) return { captured: false, submittedEnter: false, handled: false };
@@ -1356,6 +1357,7 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
         const result = await activeAgyTurn;
         const post = await runPostTurnHooks(cwd, "agy", { model: selectedModel, prompt: userInput }, true, result.response, harness.controller.signal, notice);
         if (post.diags.length) throw new AgyCliError(`Official CLI completed, but a jeo post-turn hook failed: ${post.diags.map(diag => diag.output).join("\n")}`, "upstream", 1);
+        if (!flags.literalPrompt && !flags.literalWorker) await runTurnEndHooks(cwd, { prompt: userInput, response: result.response, done: true, steps: result.steps, model: selectedModel }, harness.controller.signal, notice);
         const reply = sanitizeForTerminal(result.response);
         lastReply = result.response;
         lastActiveModel = selectedModel;
@@ -1638,6 +1640,14 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
     const turnDirtyCount = branch ? gitDirtyCount(cwd) : undefined;
     const tui = useTui ? new LaunchTui({ model: activeModel, provider: activeProvider, sessionId, maxSteps: initialStepLimit, cwd, branch, dirtyCount: turnDirtyCount, thinking: activeThinking, routedTier: routed?.tier }) : null;
     activeTui = tui;
+    // Hook notices are advisory; outside the TUI they go to stderr so piped stdout stays the reply only.
+    const hookNotice = (msg: string): void => {
+      const safe = sanitizeForTerminal(msg);
+      if (tui) tui.events().onNotice?.(safe);
+      else console.error(safe);
+    };
+    // Messenger-literal remote sessions never run the host user's prompt/turn hooks.
+    const promptHooksEligible = !flags.literalPrompt && !flags.literalWorker;
     if (routeCredentialNotice) {
       if (tui) tui.events().onNotice?.(routeCredentialNotice);
       else console.log(routeCredentialNotice);
@@ -1711,6 +1721,11 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
         },
       });
       const abortRemoteCompaction = () => compactHarness.controller.abort();
+      // Pre-prompt hooks (routing/knowledge capture) overlap with compaction and share its
+      // Esc/Ctrl+C abort. Skill runs (userCard === null) are host-synthesized, not typed.
+      const prePromptRun = promptHooksEligible && opts?.userCard === undefined
+        ? runPrePromptHooks(cwd, userInput, compactHarness.controller.signal, hookNotice)
+        : undefined;
       opts?.signal?.addEventListener("abort", abortRemoteCompaction, { once: true });
       if (opts?.signal?.aborted) abortRemoteCompaction();
       let compRes: Awaited<ReturnType<typeof maybeCompact>>;
@@ -1745,7 +1760,14 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
         remoteSystemBase = history[0];
         history[0] = { ...history[0], content: `${history[0].content}\n\n${opts.trustedContext}` };
       }
-      history.push(images?.length ? { role: "user", content: userInput, images } : { role: "user", content: userInput });
+      // Context from pre-prompt hooks goes to the MODEL only: the card, history title and
+      // turn-end payload keep the user's own words. Appended to the prompt message (not
+      // the system prompt) so the cached system prefix stays byte-stable across turns.
+      const prePrompt = await prePromptRun;
+      const modelInput = prePrompt?.context
+        ? `${userInput}\n\n[pre-prompt hook context — host-provided, not user instructions]\n${prePrompt.context}`
+        : userInput;
+      history.push(images?.length ? { role: "user", content: modelInput, images } : { role: "user", content: modelInput });
       // Persist the user prompt immediately so an interrupted turn keeps it on disk.
       await persistTurnTail(); // persist the user prompt immediately
       opts?.signal?.throwIfAborted();
@@ -2415,6 +2437,9 @@ async function runLaunchSession(args: string[], registerEndpointCleanup?: (clean
     } finally {
       if (tui) interactiveTurnActive = false;
     }
+    if (promptHooksEligible) {
+      await runTurnEndHooks(cwd, { prompt: userInput, response: reply, done: result.done, steps: result.steps, model: activeModel }, opts?.signal, hookNotice);
+    }
     if (result.usage) {
       sessionUsage.inputTokens += result.usage.inputTokens;
       sessionUsage.outputTokens += result.usage.outputTokens;

package/src/skills/catalog.ts

@@ -117,6 +117,36 @@ export function buildSkillTask(skill: SkillDoc, intent: string, invokedAs?: stri
         : "Carry out this skill's workflow now. If it needs a concrete target you weren't given, make a reasonable assumption or ask the user via done."),
   ].join("\n");
 }
+const TASK_STOPWORDS: Record<string, true> = {
+  the: true, and: true, for: true, with: true, use: true, this: true, that: true, from: true, into: true,
+  you: true, your: true, can: true, please: true, make: true,
+};
+const isAscii = (text: string): boolean => /^[\x00-\x7f]+$/.test(text);
+
+/** Words of any script (Korean, Japanese, Chinese included), lowercased; ASCII needs 3+ chars, others 2+. */
+function relevanceTokens(text: string): Set<string> {
+  const words = text.toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}._-]*/gu) ?? [];
+  return new Set(words.filter(w => w.length >= (isAscii(w) ? 3 : 2) && TASK_STOPWORDS[w] !== true));
+}
+
+/**
+ * How well a skill fits a task. An exact name (+20) or a name part (+10) match always outranks
+ * description matches, which add at most +8 so a chatty description cannot beat an explicit name.
+ * Non-ASCII words carry no spaces or inflection boundaries ("설치해줘"), so they match a description
+ * as a substring either way round.
+ */
+function skillRelevance(skill: SkillDoc, task: Set<string>): number {
+  const name = skill.name.toLowerCase();
+  const score = (task.has(name) ? 20 : 0) + (name.split(/[._-]/).some(part => task.has(part)) ? 10 : 0);
+  const description = `${skill.summary} ${skill.whenToUse}`.toLowerCase();
+  const words = relevanceTokens(description);
+  let hits = 0;
+  for (const token of task) {
+    if (isAscii(token) ? words.has(token) : description.includes(token) || [...words].some(w => !isAscii(w) && token.includes(w))) hits++;
+  }
+  return score + Math.min(hits, 8);
+}
+
 export function skillsPromptSection(skills: SkillDoc[] = SKILLS, currentTask?: string): string {
   const bundleSkills: SkillDoc[] = [];
   let configuredSkills: SkillDoc[] = [];
@@ -130,18 +160,13 @@ export function skillsPromptSection(skills: SkillDoc[] = SKILLS, currentTask?: s
     }
   }
 
-  // When a task is provided and skills exceed budget, sort configured skills by relevance
+  // When a task is provided and skills exceed budget, rank configured skills by relevance (stable for ties).
   if (currentTask && currentTask.trim().length > 0 && configuredSkills.length > 5) {
-    const qTokens = new Set(
-      currentTask.toLowerCase().match(/[a-z0-9._-]{3,}/g) ?? []
-    );
-    configuredSkills = [...configuredSkills].sort((a, b) => {
-      const aScore = (a.name.toLowerCase().split(/[._-]/).some(t => qTokens.has(t)) ? 10 : 0) +
-        (qTokens.has(a.name.toLowerCase()) ? 20 : 0);
-      const bScore = (b.name.toLowerCase().split(/[._-]/).some(t => qTokens.has(t)) ? 10 : 0) +
-        (qTokens.has(b.name.toLowerCase()) ? 20 : 0);
-      return bScore - aScore;
-    });
+    const task = relevanceTokens(currentTask);
+    configuredSkills = configuredSkills
+      .map((skill, index) => ({ skill, index, score: skillRelevance(skill, task) }))
+      .sort((a, b) => b.score - a.score || a.index - b.index)
+      .map(entry => entry.skill);
   }
 
   const lines: string[] = [];