jeo-code 0.12.1 → 0.12.3

package/src/commands/launch.ts

@@ -54,6 +54,10 @@ import chalk from "chalk";
 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 { runPreToolHooks, runPostTurnHooks } from "../agent/hooks";
+import { runAgySessionTurn } from "./launch/agy-turn";
+import { listProviderModels } from "../ai/model-discovery";
 import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recency";
 import { describeModel, describeAllProviders, describeProvider, resolveProvider, thinkingMaxTokens, resolveMaxOutputTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, catalogByProvider, liveProviderCatalogModels, resolveRoleModel, CODEX_MODELS, qualifyModelId, modelServableWithConfig, isLocalProviderReachable } from "../ai";
 import { rehydrateLiveModels, writeModelCache } from "../ai/model-cache";
@@ -350,7 +354,7 @@ export function providerPickEntries(live: ProviderModelsResult[], want: Provider
   if (fromLive.length) return fromLive;
   // An OpenAI or Antigravity empty/error response is authoritative for this picker.
   // Offering the static capability catalog here would fabricate account availability.
-  if (want === "openai" || want === "antigravity") return [];
+  if (want === "openai" || want === "antigravity" || want === "agy") return [];
   const catalog = catalogByProvider(want);
   if (catalog.length) {
     return catalog.map((m, i) => ({ index: i + 1, provider: want, model: qualifyModelId(m.providerModel, want) }));
@@ -420,9 +424,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   } catch {}
   const cfg = await readGlobalConfig();
   const defaultModel = cfg.defaultModel;
-  const initialSessionModel =
+  let initialSessionModel =
     flags.model ??
     (flags.modelRole ? resolveRoleModel(flags.modelRole, cfg) : flags.provider ? providerDefaultModel(flags.provider) : undefined);
+  if (flags.provider === "agy" && !flags.model && !flags.modelRole) {
+    const available = await listProviderModels("agy", { config: cfg });
+    if (!available.ok || !available.models.length) {
+      console.error(sanitizeForTerminal(`error: ${available.error ?? "the official agy CLI returned no available models"}`));
+      process.exitCode = 1;
+      return;
+    }
+    initialSessionModel = available.models[0];
+  }
   if (flags.provider && initialSessionModel) {
     const { provider } = await describeModel(initialSessionModel);
     if (provider !== flags.provider) {
@@ -955,6 +968,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const subagentRegistry = new SubagentRegistry();
   const jobRegistry = new JobRegistry();
   let activeTui: LaunchTui | null = null;
+  let activeAgyController: AbortController | undefined;
+  let activeAgyTurn: Promise<AgyTurnResult> | undefined;
   const monitorRegistry = new MonitorRegistry({
     onLine: (record, line) => {
       const notice = `[monitor ${record.id}] ${line}`;
@@ -968,6 +983,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const cleanupSession = async (): Promise<void> => {
     if (cleanedUp) return;
     cleanedUp = true;
+    activeAgyController?.abort();
+    await activeAgyTurn?.catch(() => undefined);
     subagentRegistry.cancelAll();
     jobRegistry.cancelAll();
     monitorRegistry.cancelAll();
@@ -1048,6 +1065,96 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // gjc-style); a string → show that compact label instead of the raw input.
     opts?: { userCard?: string | null },
   ): Promise<{ done: boolean; steps: number; reply: string; rendered: boolean; usage: string }> => {
+    const selectedModel = sessionModel || defaultModel;
+    if (selectedModel.startsWith("agy/")) {
+      const oneShot = !!flags.print || flags.message.length > 0 || !process.stdin.isTTY;
+      if (flags.noTools || flags.tools || flags.maxSteps > 0 || flags.systemPrompt || flags.appendSystemPrompt || flags.thinking) {
+        if (oneShot) process.exitCode = 1;
+        throw new AgyCliError("The official agy agent owns its tools, system prompt, step budget, and reasoning settings. Remove jeo's raw-model tool/system/step/thinking flags and select an exact agy model slug instead.", "protocol", 1);
+      }
+      const cliTui = useTui ? new LaunchTui({ model: selectedModel, provider: "agy", sessionId, maxSteps: 0, cwd, branch }) : null;
+      const notice = (message: string): void => {
+        const safe = sanitizeForTerminal(message);
+        if (cliTui) cliTui.events().onNotice?.(safe);
+        else console.error(safe);
+      };
+      let hardExit = false;
+      const harness = createInFlightAbortHarness({
+        captureEsc: !!cliTui,
+        onAbortNotice: notice,
+        onNoise: () => cliTui?.repaint(),
+        pasteActive: () => queueBusyPasteActive?.() ?? false,
+        onBufferedInput: chunk => {
+          if (queueBusyInput?.(chunk) && jeoEnv("NO_LIVE_DRAFT") !== "1") {
+            cliTui?.setLivePromptInput(expandSentinel(queueBusySnapshot?.().text ?? ""));
+          }
+        },
+        onHardExit: () => { hardExit = true; },
+      });
+      activeAgyController = harness.controller;
+      activeTui = cliTui;
+      interactiveTurnActive = !!cliTui;
+      lastUserInput = userInput;
+      lastTurnReasoning = "";
+      lastTurnArtifacts = [];
+      try {
+        cliTui?.start();
+        cliTui?.setTurnTitle(userInput);
+        const card = opts?.userCard === undefined ? userInput : opts.userCard;
+        if (card?.trim()) cliTui?.flushUserCard(card);
+        notice("Official agy agent: uses its own tools, sandbox, and permissions; jeo approvals do not mediate its inner tool calls.");
+        const pre = await runPreToolHooks(cwd, "agy", { model: selectedModel, prompt: userInput }, harness.controller.signal, notice);
+        if (pre.vetoed) throw new AgyCliError(pre.error ?? "Official CLI delegation blocked by a jeo hook", "upstream", 1);
+        sessionNotifyEndpoint?.sendContextUpdate("turn_start", notifyRedact ? "[redacted]" : userInput.slice(0, 200), { model: selectedModel });
+        let streamed = "";
+        activeAgyTurn = runAgySessionTurn({
+          model: selectedModel, prompt: userInput, cwd, history, sessionId, images,
+          signal: harness.controller.signal,
+          mode: flags.modelRole === "plan" ? "plan" : undefined,
+          onNotice: notice,
+          onText: cliTui ? text => {
+            streamed += sanitizeForTerminal(text);
+            cliTui.events().onModelStream?.(streamed);
+          } : undefined,
+        });
+        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);
+        const reply = sanitizeForTerminal(result.response);
+        lastReply = result.response;
+        lastActiveModel = selectedModel;
+        if (result.usage) {
+          sessionUsage.inputTokens += result.usage.inputTokens;
+          sessionUsage.outputTokens += result.usage.outputTokens;
+          cliTui?.events().onUsage?.(result.usage);
+        }
+        sessionUsage.turns++;
+        const usage = result.usage ? `\n${formatUsage(result.usage)}` : "";
+        sessionNotifyEndpoint?.sendContextUpdate("turn_end", notifyRedact ? "[redacted]" : reply.slice(0, 200), { model: selectedModel, usage });
+        sessionNotifyEndpoint?.sendTurnStream(notifyRedact ? "[redacted]" : reply);
+        cliTui?.events().onStep?.(result.steps);
+        cliTui?.finish(reply);
+        return { done: true, steps: result.steps, reply, rendered: !!cliTui, usage };
+      } catch (error) {
+        if (oneShot) {
+          process.exitCode = error instanceof AgyCliError
+            ? (error.kind === "cancelled" ? 130 : Math.max(1, error.exitCode ?? 1))
+            : 1;
+        }
+        cliTui?.finish(`! ${friendlyProviderError(error)}`, { ok: false });
+        throw error;
+      } finally {
+        harness.dispose();
+        activeAgyTurn = undefined;
+        activeAgyController = undefined;
+        activeTui = null;
+        interactiveTurnActive = false;
+        if (hardExit) {
+          process.exitCode = 130;
+          if (!oneShot) forceExitFromCtrlC();
+        }
+      }
+    }
     const turnConfig = await readGlobalConfig();
     // Fall back to the model resolved at THIS session's start (frozen snapshot), NOT
     // the live global default. A concurrent `jeo` session running `/model` persists the
@@ -1552,7 +1659,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const fullTools = {
           ...DEFAULT_TOOLS,
           task: createTaskTool({
-            config: { ...turnConfig, defaultModel: activeModel },
+            // Subagents inherit the parent's EFFECTIVE routing state (`/route on|off`
+            // override ?? config) — task-tool.ts gates its failover reroute on it.
+            config: { ...turnConfig, defaultModel: activeModel, routing: { ...turnConfig.routing, enabled: routingEnabled } },
+
             signal: ac.signal,
             steer: drainSteer,
             registry: subagentRegistry,
@@ -1603,12 +1713,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // mutated in place (`.add`) as the fallback loop below tries more models — this
         // closure always reads its live contents, never a stale snapshot.
         const attemptedRouteModels = new Set<string>([activeModel]);
-        // A NON-routed turn (routing disabled, or the user pinned a model via /model)
-        // still needs the equivalent-pool fallback on a usage-limit/rate-limit/credential
-        // failure — the exact "5-hour usage window exhausted, model just stops working"
-        // case this loop exists to fix. Synthesize a same-size-class RouteDecision
-        // (inferTierForModel) so `equivalentRouteFallback` has a tier/pool to search even
-        // with routing off; a real `routed` decision (routing enabled) is used unchanged.
+        // The synthesized decision below is only the BASE for `equivalentRouteFallback`'s
+        // tier/pool search when the pre-call router produced no decision (routing on but
+        // fail-open, or a /model pin with `/route on`). It is inert when routing is off:
+        // the reroute loop and the engine's bail predicates are both gated on
+        // `routingEnabled`, so `/route off` means a FIXED model with no failover.
+        // (`inferTierForModel` gives the same-size-class tier/pool to search.)
+
         let fallbackBaseDecision: RouteDecision = routed ?? {
           model: activeModel,
           thinking: activeThinking,
@@ -1678,8 +1789,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           signal: ac.signal,
           sessionKey: cacheKey,
           steer: drainSteer,
-          rateLimitFallbackAvailable,
-          safetyFallbackAvailable,
+          // Withheld when routing is off: the bail predicates only make sense paired
+          // with the reroute loop below, which `routingEnabled` also gates.
+          ...(routingEnabled ? { rateLimitFallbackAvailable, safetyFallbackAvailable } : {}),
+
           events: wrapEvents(withStepPersistence({ ...withToolDetailCapture(tui ? tui.events() : streamEvents), onBeforeDone }, persistTurnTail), opik),
         });
         const routeFailureReason = (doneReason: unknown): string | null => {
@@ -1759,7 +1872,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         const routeFallbackMax = Number.isFinite(routeFallbackMaxRaw) && routeFallbackMaxRaw >= 0
           ? Math.floor(routeFallbackMaxRaw)
           : 3;
-        for (let routeFallbackAttempt = 0; routeFallbackAttempt < routeFallbackMax; routeFallbackAttempt++) {
+        for (let routeFallbackAttempt = 0; routingEnabled && routeFallbackAttempt < routeFallbackMax; routeFallbackAttempt++) {
+
           // A loop guard is a local safety boundary, not a provider failure. A
           // fresh loop on an equivalent model loses the guard state and could
           // re-execute a previously skipped mutation.
@@ -1855,10 +1969,20 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     }
     // A completed turn with an empty done-reason must NOT masquerade as a step-limit
     // failure ("reached the 3-step limit" after the model called done at step 3).
-    const reply = stripSafetyFallbackTag(result.doneReason ?? "")
+    const baseReply = stripSafetyFallbackTag(result.doneReason ?? "")
       || (result.done
         ? `(done in ${result.steps} step${result.steps === 1 ? "" : "s"} — the model returned no summary)`
         : `(reached the ${result.steps}-step limit without signaling done)`);
+    // Routing off = the model is fixed and nothing fails over. When the turn died on
+    // an account-level limit, say so and name the one switch that re-enables failover.
+    const failoverHint = !routingEnabled && !result.done && (() => {
+      const failure = new Error(result.doneReason ?? "");
+      return isRateLimitError(failure) || isUsageLimitError(failure);
+    })()
+      ? "\n(routing is off — the model is fixed and no equivalent-model failover was attempted. Run '/route on' to allow failover.)"
+      : "";
+    const reply = `${baseReply}${failoverHint}`;
+
     if (sessionNotifyEndpoint) {
       const usageStr = result.usage ? formatUsage(result.usage) : undefined;
       if (notifyRedact) {
@@ -1965,7 +2089,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // > 0) and stays silent (no stdout noise) since one-shot output may be
   // piped/parsed by a script.
   const maybeDistillOneShot = async (): Promise<void> => {
-    if (sessionUsage.turns > 0) {
+    if (sessionUsage.turns > 0 && !(sessionModel || defaultModel).startsWith("agy/")) {
       await spawnDetachedDistill(history, cwd, sessionModel || defaultModel);
     }
   };
@@ -5152,7 +5276,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // hermes-style experience distill (plan/gjc-inheritance.md B6) — now handed to a
   // DETACHED child (round-16): /exit and ^C^C return the shell IMMEDIATELY instead
   // of blocking up to 20s on a final LLM call. The child writes MEMORY.md atomically.
-  if (sessionUsage.turns > 0) {
+  if (sessionUsage.turns > 0 && !(sessionModel || defaultModel).startsWith("agy/")) {
     const spawned = await spawnDetachedDistill(history, cwd, sessionModel || defaultModel);
     if (spawned) console.log(chalk.gray("(session memory distilling in background)"));
   }

package/src/util/provider-error.ts

@@ -7,6 +7,8 @@
 import { isUsageLimitError, isRefusalError, isConnectionError, ConnectionContextError } from "./retry";
 import { companyLabel } from "../ai/model-catalog";
 import { ProviderHttpError, ProviderStreamError } from "../ai/providers/errors";
+import { AgyCliError } from "../agent/antigravity-cli";
+import { sanitizeForTerminal } from "../tui/components/code-view";
 // Re-export: engine.ts and callers import the refusal predicate from here; the
 // definition lives in retry.ts so defaultRetryable can fail fast without a cycle.
 export { isRefusalError } from "./retry";
@@ -71,6 +73,7 @@ function retryAfterMsOf(err: unknown): number | undefined {
 }
 
 export function friendlyProviderError(err: unknown): string {
+  if (err instanceof AgyCliError) return sanitizeForTerminal(err.message);
   if (err instanceof ConnectionContextError) {
     const provider = companyLabel(err.provider);
     const target = err.baseUrl ? ` at ${err.baseUrl}` : "";