jeo-code 0.12.21 → 0.12.23

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/cli/runner.ts

@@ -235,7 +235,7 @@ export const COMMANDS: readonly CommandSpec[] = [
   {
     name: "update",
     summary: "Update jeo-code to the latest npm release (bare = install; --check only checks).",
-    usage: "update [--check|--install] [--json] [--strict] [--version <semver>]",
+    usage: "update [--check|--install] [--json] [--strict] [--version <semver>] [--allow-unlocked-global]",
     loader: async () => {
       const m = await import("../commands/update");
       return args => m.runUpdateCommand(args);

package/src/commands/doctor.ts

@@ -14,6 +14,9 @@ import { visibleWidth, truncateToWidth } from "../tui/components/width";
 import chalk from "chalk";
 import { extractChatgptAccountId, CODEX_RESPONSES_URL } from "../ai/providers/openai-responses";
 import { resolveTierModel, tierModelPool, cheapestCredentialed } from "../agent/prompt-router";
+import { DEFAULT_SIZE_CAP_MS, collectSharedInstallReport, type SharedInstallReport } from "../util/shared-install-report";
+import { formatBytes } from "../tui/components/session-picker";
+import { compareVersions } from "./update";
 
 interface ProbeResult {
   status: "ok" | "fail" | "skipped";
@@ -219,7 +222,93 @@ function providerTableLines(
   return renderMarkdownTables(md, { unicode, maxColWidth: detailBudget }).split("\n");
 }
 
-export async function runDoctorCommand(args: string[] = []): Promise<void> {
+export interface DoctorDeps {
+  /** Produces the shared bun global report; tests inject it, the default scans the real machine (memoized). */
+  sharedInstall?: () => SharedInstallReport | Promise<SharedInstallReport>;
+}
+
+const SHARED_INSTALL_TTL_MS = 30_000;
+let sharedInstallMemo: { key: string; at: number; report: SharedInstallReport } | undefined;
+
+/** The real scan, memoized for 30 s per environment so repeated doctor runs in one process walk the global dir once. */
+function defaultSharedInstall(): SharedInstallReport {
+  const key = [process.env.HOME, process.env.BUN_INSTALL, process.env.BUN_INSTALL_GLOBAL_DIR, process.env.XDG_CONFIG_HOME, process.env.PATH, process.platform].join("|");
+  if (sharedInstallMemo?.key === key && Date.now() - sharedInstallMemo.at < SHARED_INSTALL_TTL_MS) return sharedInstallMemo.report;
+  const report = collectSharedInstallReport();
+  sharedInstallMemo = { key, at: Date.now(), report };
+  return report;
+}
+
+const ORPHAN_KIND_NOTE: Record<"directory" | "symlink" | "dangling-symlink", string> = {
+  directory: "possible orphan",
+  symlink: "possible orphan, symlink",
+  "dangling-symlink": "possible orphan, dangling symlink",
+};
+
+/** Human text for the shared install section. Warnings are yellow, an ok lockfile green; paths are never truncated. */
+function sharedInstallLines(report: SharedInstallReport): string[] {
+  const lines: string[] = [];
+  const { manifest, lockfile, leftovers, sizes } = report;
+  if (report.skipped !== null) {
+    lines.push(`Shared install: no usable bun global (${report.skipped}); lockfile, leftover and size checks skipped.`);
+  } else {
+    lines.push(`Shared install (${report.globalDir ?? "unknown"}):`);
+  }
+  if (manifest !== null) lines.push(`  packages:  ${manifest.dependencies} in manifest (${manifest.external} besides jeo-code)`);
+  if (lockfile !== null) {
+    if (lockfile.status === "ok") {
+      const total = manifest?.external ?? lockfile.uncovered.length;
+      lines.push(chalk.green(`  bun.lock:  ok (${total - lockfile.uncovered.length} of ${total} covered)`));
+    } else if (lockfile.status === "not-required") {
+      lines.push("  bun.lock:  not required (jeo-code is the only package)");
+    } else if (lockfile.status === "missing") {
+      lines.push(chalk.yellow("  bun.lock:  MISSING - jeo update will refuse until it is restored (or pass --allow-unlocked-global)"));
+    } else if (lockfile.status === "incomplete") {
+      lines.push(chalk.yellow(`  bun.lock:  INCOMPLETE - no resolved entry for: ${lockfile.uncovered.join(", ")}`));
+    } else {
+      lines.push(chalk.yellow(`  bun.lock:  UNREADABLE${lockfile.detail ? ` (${lockfile.detail})` : ""}`));
+    }
+  }
+  if (report.jeoOnPath.length === 0) {
+    lines.push("  jeo on PATH: none found");
+  } else {
+    const activeVersion = report.jeoOnPath.find(entry => entry.active)?.version ?? null;
+    lines.push("  jeo on PATH (first = active):");
+    for (const entry of report.jeoOnPath) {
+      const marker = entry.active ? "*" : " ";
+      const text = `    ${marker} ${entry.path}  ${entry.version ?? "(version unknown)"}${entry.active ? " (active)" : ""}`;
+      if (entry.stale && entry.version !== null && activeVersion !== null) {
+        const direction = compareVersions(entry.version, activeVersion) < 0 ? "older" : "newer";
+        lines.push(chalk.yellow(`${text} [stale: ${direction} than active ${activeVersion}]`));
+      } else {
+        lines.push(text);
+      }
+    }
+  }
+  if (leftovers !== null) {
+    if (leftovers.backupFiles.length === 0 && leftovers.possibleOrphans.length === 0 && leftovers.orphanScanComplete) {
+      lines.push("  leftovers: none");
+    } else {
+      lines.push("  leftovers (not touched):");
+      for (const file of leftovers.backupFiles) lines.push(chalk.yellow(`    file    ${file}`));
+      for (const orphan of leftovers.possibleOrphans) lines.push(chalk.yellow(`    orphan  ${orphan.name} (${ORPHAN_KIND_NOTE[orphan.kind]})`));
+      if (!leftovers.orphanScanComplete) lines.push(chalk.yellow("    orphan scan stopped at its cap; no orphans reported"));
+    }
+  }
+  if (sizes !== null) {
+    const top = `top ${sizes.top.length}: ${sizes.top.map(p => `${p.name} ${formatBytes(p.bytes)}`).join(", ")}`;
+    if (sizes.capped === null) {
+      lines.push(`  size: ${formatBytes(sizes.totalBytes)} total${sizes.top.length > 0 ? `; ${top}` : ""}`);
+    } else {
+      const cap = sizes.capped === "time" ? `time cap (${DEFAULT_SIZE_CAP_MS} ms)` : `entry cap (${sizes.scannedEntries} entries)`;
+      lines.push(chalk.yellow(`  size scan stopped at the ${cap}; figures are lower bounds`));
+      lines.push(`    at least ${formatBytes(sizes.totalBytes)} scanned${sizes.top.length > 0 ? `; ${top}` : ""}`);
+    }
+  }
+  return lines;
+}
+
+export async function runDoctorCommand(args: string[] = [], deps: DoctorDeps = {}): Promise<void> {
   const strict = args.includes("--strict");
   const json = args.includes("--json");
   const config = await readGlobalConfig();
@@ -379,6 +468,14 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
     ? defaultProbe?.result.status === "skipped"
     : defaultProbe?.result.status === "ok";
 
+  // Shared bun global diagnostics: read-only, never affects `ready` or the exit code.
+  let sharedInstall: SharedInstallReport | { error: string };
+  try {
+    sharedInstall = await (deps.sharedInstall ?? defaultSharedInstall)();
+  } catch (err) {
+    sharedInstall = { error: err instanceof Error ? err.message : String(err) };
+  }
+
   // --- JSON output mode (CI / scripting) ---
   if (json) {
     const report = {
@@ -402,6 +499,7 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
       oauth: oauthHealth,
       ready,
       ...(routingEnabled ? { routing: { enabled: true, smolConfigured, preview: routingPreview, ...(routingNotes.length ? { notes: routingNotes } : {}) } } : {}),
+      sharedInstall,
 
     };
     console.log(JSON.stringify(report, null, 2));
@@ -490,6 +588,13 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
     console.log("");
   }
 
+  if ("error" in sharedInstall) {
+    console.log(chalk.yellow(`Shared install: check failed (${sharedInstall.error})`));
+  } else {
+    for (const line of sharedInstallLines(sharedInstall)) console.log(line);
+  }
+  console.log("");
+
   // 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";
@@ -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;