jeo-code 0.7.27 → 0.7.28

package/CHANGELOG.md

@@ -6,6 +6,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.7.28] - 2026-07-02
+_gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests)._
+
+### Fixed
+- **Generic 429 rate limits with a long server `Retry-After` were treated as FATAL — gajae 0.7.10 (#1370) keeps them retryable, and now jeo does too.** The old behavior failed fast on any 429 whose server-directed delay exceeded a hard-coded 5-minute budget, and silently compressed every honored `Retry-After` to 30s (retrying into a still-closed window). gjc's contract (verified against its `agent-session-retry-cap` tests): a transient rate limit honors the provider's wait IN FULL — even a ~3.1h `retry-after-ms=11180000` — while usage/quota/model-limit errors keep failing fast via `isUsageLimitError` → `defaultRetryable`. `withRetry` (`src/util/retry.ts`) now honors server-directed delays uncapped (the 30s `RATE_LIMIT_FLOOR_CAP_MS` only caps the SYNTHETIC escalating floor for server-silent 429s), and `resolveRetryOptions` no longer injects a default `rateLimitMaxServerDelayMs` — it remains available as explicit opt-in config (`retry.rateLimitMaxServerDelayMs`, added to the Config type + zod schema).
+- **A long honored rate-limit wait is now user-cancellable.** `RetryOptions.signal` (new) aborts an in-progress backoff sleep: `resolveCall` threads the caller's ORIGINAL abort signal (Ctrl-C / turn abort) into the retry layer — distinct from the per-attempt fetch timeout, so one attempt's timeout can never cut short the next attempt's backoff, while Esc/Ctrl-C interrupts a multi-hour wait immediately instead of after the sleep elapses.
+- **`isUsageLimitError` missed gajae's usage-exhaustion phrasings.** Added `model.?limit` / `message.?limit` / `limit for this model` / `out_of_credits` / Anthropic's account-level `request would exceed your account's rate limit` and the qualified `Resource has been exhausted (… quota/limit)` form (bare gRPC `resource exhausted` stays transient — deliberate jeo choice for Gemini windows that clear quickly). Without these, an out-of-credits 429 was retried on a pointless backoff ladder instead of failing fast to the model/credential-switch hint.
+- **Anthropic 429s now carry their rate-limit response headers in the error detail** (gjc `getSafeAnthropicHeaderEvidence` parity): `retry-after`, `retry-after-ms`, and every `anthropic-ratelimit-*` header — including the decisive `anthropic-ratelimit-unified-overage-disabled-reason=out_of_credits`, which often arrives ONLY as a header. Without it an out-of-credits 429 read like a generic per-minute rate limit.
+
+### Added
+- **Kimi Code (Moonshot coding subscription) OAuth — completed end-to-end.** The device-code flow (`src/auth/flows/kimi.ts`, RFC 8628: `auth.kimi.com` device_authorization → poll with `authorization_pending`/`slow_down`/`expired_token`/`access_denied` semantics, X-Msh-* device headers, persisted `kimi-device-id`) now has: catalog entries for the Kimi Code models (`kimi-for-coding`, `kimi-k2.7-code`, `kimi/kimi-k2.5`, `kimi/kimi-k2-turbo-preview`, `kimi/kimi-k2` — 262k context, provider-qualified where canonicals collide with tencent's), a `KIMI_CODE_MODELS` export, OAuth gating (`oauthServesModel`: kimi OAuth serves ONLY the Kimi Code set; Moonshot API ids fall back to `KIMI_API_KEY` via `effectiveCredentialForProvider`, with an actionable error when no key exists), and an OAuth-only discovery fallback that lists exactly the Kimi Code models (`catalogOr`) instead of faking moonshot ids. The `kimiAdapter` dispatches on credential kind — OAuth → Anthropic-compatible `api.kimi.com/coding/v1/messages` with plain Bearer + X-Msh headers (no Claude-Code cloaking; gated by `shouldUseClaudeCodeOAuthShape`'s baseUrl check), api_key → the unchanged OpenAI-compatible `api.moonshot.ai/v1`.
+- **Codex/Responses provider-side prompt caching (gjc parity — closes the `ponytail` note in `openai-responses.ts`).** New `CallOptions.sessionKey` threads a stable per-conversation key from `launch.ts` (the session id), `team.ts`, and `task-tool.ts` (per-run UUIDs) through the engine loop into every model call. `codexResponsesRequest` stamps it as `prompt_cache_key` in the body (both the OAuth Codex backend and the public `api.openai.com/v1/responses`) plus `session_id`/`conversation_id`/`x-client-request-id` correlation headers on the Codex backend (`normalizePromptCacheKey`: ≤64 chars verbatim, longer keys hashed `pc_*` — gjc `normalizeOpenAIResponsesPromptCacheKey` parity). An agent loop replays nearly-identical history each step, so cache hits cut both latency and billed input tokens.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 2142 pass / 0 fail across 244 files (before the codex/kimi test additions), then targeted suites re-run green: `retry` (26), `rate-limit-handling` (5), `provider-errors`, `round-b`, `kimi-provider` (7 new), `kimi-oauth` (7 new), `codex-responses` (+3 new). The corrected rate-limit contract is pinned by tests that mirror gjc's own fixtures (3.1h retry-after honored + recovered; model-limit fails fast; mid-wait abort interrupts the sleep).
+
 ## [0.7.27] - 2026-07-02
 _Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks._
 

package/README.ja.md

@@ -205,11 +205,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
 - **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
 - **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
-- **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -205,11 +205,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
 - **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
 - **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
-- **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -232,11 +232,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
 - **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
 - **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
-- **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -205,11 +205,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.28]** (2026-07-02) — gajae-code 0.7.9–0.7.10 OAuth + model-execution parity: generic long rate-limit windows are retried (never fatal), retry waits are abort-cancellable, Codex prompt caching via session correlation, and the Kimi Code device-flow OAuth is completed end-to-end (catalog, gating, discovery, tests).
 - **[0.7.27]** (2026-07-02) — Extended-keyboard decode layer: Esc/Ctrl+C work again on kitty-protocol terminals, Shift+Enter breaks lines on every terminal incl. Windows, row/draft-aware Cmd+←→/↑↓ + Home/End/Ctrl+Home/End, Ctrl+V text-paste fallback. Plus Anthropic 5th-gen omp-parity: catalog-derived output budgets end thinking-vs-reply starvation; refusals fail fast at the transport and the recovery ladder strips replayed thinking blocks.
 - **[0.7.26]** (2026-07-02) — Esc/Ctrl+C reliably clears the input box (fixes a gate the earlier reorder missed), and un-bracketed multi-line pastes no longer shred into premature per-line submits.
 - **[0.7.25]** (2026-07-02) — Shift+Enter now reliably distinguishable from Enter on kitty/WezTerm/iTerm2/xterm via modifyOtherKeys + kitty keyboard protocol; row-aware Home/End and Cmd+Left/Right in multi-row drafts.
 - **[0.7.24]** (2026-07-02) — OAuth callback page redesign with embedded jeo wordmark + Close button; memory budget O(n²)→O(n) incremental tracking fix.
-- **[0.7.23]** (2026-07-01) — Anthropic 5th-generation model catalog: adds Sonnet 5, Fable 5, and Mythos 5, promotes the 4.6 generation to 1M context / 128k output, and retires the superseded 4.5/3.5/4.1 ids. Bumps the default model to Sonnet 4.6, prices the new tiers, and fixes the thinking transport for Haiku 4.5 and every 5th-gen model.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.27",
+  "version": "0.7.28",
 
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",

package/src/agent/config-schema.ts

@@ -105,6 +105,7 @@ export const ConfigSchema = z
         maxDelayMs: z.number().int().min(0).optional(),
         rateLimitRetries: z.number().int().min(0).optional(),
         rateLimitMinDelayMs: z.number().int().min(0).optional(),
+        rateLimitMaxServerDelayMs: z.number().int().min(0).optional(),
       })
       .optional(),
     /**

package/src/agent/engine.ts

@@ -40,6 +40,7 @@ async function invokeCallLlm(history: Message[], options: {
   onReasoningStart?: () => void;
   onReasoningArtifact?: (artifact: import("../ai/types").ReasoningArtifact) => void;
   tools?: import("../ai/types").NativeToolSchema[];
+  sessionKey?: string;
 }): Promise<string> {
   const mod = await import("./loop");
   return mod.callLlm(history, options);
@@ -265,6 +266,11 @@ export interface AgentLoopOptions {
    *  so an additional query typed while the turn runs steers the live turn instead of
    *  waiting for the next prompt. Return [] when nothing is pending. */
   steer?: () => string[];
+  /** Stable per-conversation key (the session id): threaded to every model call for
+   *  provider-side prompt caching (gjc parity — Codex prompt_cache_key/session_id).
+   *  An agent loop replays nearly-identical history each step, so cache hits here cut
+   *  both latency and billed input tokens. */
+  sessionKey?: string;
 }
 
 export interface AgentLoopResult {
@@ -388,7 +394,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
                 "with what you have already found this turn, and state explicitly anything that is still uncertain.",
             },
           ],
-          { jsonMode: false, model: opts.model, maxTokens: opts.maxTokens, signal: opts.signal },
+          { jsonMode: false, model: opts.model, maxTokens: opts.maxTokens, signal: opts.signal, sessionKey: opts.sessionKey },
         );
         const consolidated = wrapUp.trim();
         if (consolidated) {
@@ -557,6 +563,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
               maxTokens: opts.maxTokens,
               reasoningEffort: opts.reasoningEffort,
               signal: opts.signal,
+              sessionKey: opts.sessionKey,
               onUsage: u => { acc.inputTokens += u.inputTokens ?? 0; acc.outputTokens += u.outputTokens ?? 0; sawUsage = true; },
               onToken,
               onReasoning,
@@ -1132,7 +1139,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
               "the key findings/changes so far, and what remains to be done next.",
           },
         ],
-        { jsonMode: false, model: opts.model, maxTokens: opts.maxTokens, signal: opts.signal },
+        { jsonMode: false, model: opts.model, maxTokens: opts.maxTokens, signal: opts.signal, sessionKey: opts.sessionKey },
       );
       const consolidated = wrapUp.trim();
       if (consolidated) {

package/src/agent/loop.ts

@@ -31,6 +31,9 @@ export interface ChatOptions {
   onReasoningArtifact?: (artifact: import("../ai/types").ReasoningArtifact) => void;
   /** NATIVE tool-calling function declarations (forwarded to capable adapters). */
   tools?: import("../ai/types").NativeToolSchema[];
+  /** Stable per-conversation key (session id) for provider-side prompt caching
+   *  (gjc parity: prompt_cache_key / session_id correlation on Codex/Responses). */
+  sessionKey?: string;
 }
 
 const manager = createModelManager();

package/src/agent/state.ts

@@ -78,6 +78,11 @@ export interface Config {
     rateLimitRetries?: number;
     /** Minimum backoff (ms) for a 429 when the server sends no Retry-After. */
     rateLimitMinDelayMs?: number;
+    /** Opt-in ceiling (ms) on a 429's server-directed Retry-After: a delay beyond it fails
+     *  fast instead of sleeping. Unset (the default) honors any server-directed delay in
+     *  full, however long — a generic rate limit is retried forever, not treated as fatal
+     *  past some budget. Set this only if unbounded rate-limit waits are undesirable. */
+    rateLimitMaxServerDelayMs?: number;
     /** HTTP statuses to treat as NON-retryable even when defaultRetryable would
      *  retry them (e.g. pin 503 to fail fast instead of riding the backoff ladder). */
     failFastStatuses?: number[];
@@ -385,14 +390,88 @@ export async function readRawGlobalConfig(): Promise<Config> {
   return salvageCredentials(clean, parsed);
 }
 
+/**
+ * Global config write lock — HIGH-1 lost-update fix (gjc parity: auth-storage.ts
+ * SqliteAuthCredentialStore serializes credential writes inside SQLite). jeo keeps
+ * everything in one config.json, so EVERY read-modify-write must serialize through one
+ * lock file; otherwise two concurrent per-provider OAuth refreshes (e.g. doctor.ts
+ * Promise.all) read the same base config and the later write clobbers the earlier one's
+ * just-rotated refresh token → silent logout.
+ *
+ * Semantics mirror src/auth/storage.ts acquireLock (stale-lock detection + bounded wait
+ * + single steal at the deadline) but are implemented locally: storage.ts imports
+ * state.ts, so importing it back would create a cycle.
+ * // ponytail: extract a shared lockfile helper module if a third lockfile user appears.
+ */
+const CONFIG_LOCK_STALE_MS = 5_000;
+
+function configLockPath(): string {
+  return `${globalConfigPath()}.lock`;
+}
+
+async function acquireConfigLock(timeoutMs = CONFIG_LOCK_STALE_MS): Promise<void> {
+  const lockPath = configLockPath();
+  await fs.mkdir(path.dirname(lockPath), { recursive: true, mode: 0o700 });
+  // `timeoutMs` is the STALENESS threshold for a dead holder's lock file; the
+  // acquisition wait itself is bounded at 2× that (same policy as storage.ts).
+  const deadline = Date.now() + Math.max(timeoutMs * 2, 1_000);
+  while (true) {
+    try {
+      const handle = await fs.open(lockPath, "wx");
+      await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: Date.now() }), "utf-8");
+      await handle.close();
+      return;
+    } catch (err: any) {
+      if (err.code !== "EEXIST") throw err;
+      try {
+        const info = JSON.parse(await fs.readFile(lockPath, "utf-8"));
+        if (typeof info.createdAt === "number" && info.createdAt + timeoutMs < Date.now()) {
+          await fs.unlink(lockPath).catch(() => {});
+        }
+      } catch {
+        try {
+          const stat = await fs.stat(lockPath);
+          if (stat.mtimeMs + timeoutMs < Date.now()) {
+            await fs.unlink(lockPath).catch(() => {});
+          }
+        } catch {}
+      }
+    }
+    if (Date.now() >= deadline) {
+      // Deadline reached: the holder is dead or wedged. Steal once — the lock guards
+      // a short config read-modify-write, so waiting longer only hangs the caller.
+      await fs.unlink(lockPath).catch(() => {});
+      const handle = await fs.open(lockPath, "wx").catch(() => null);
+      if (handle) {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: Date.now(), stolen: true }), "utf-8");
+        await handle.close();
+        return;
+      }
+      throw new Error(`config lock could not be acquired within ${Math.max(timeoutMs * 2, 1_000)}ms (${lockPath})`);
+    }
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+}
+
+async function releaseConfigLock(): Promise<void> {
+  await fs.unlink(configLockPath()).catch(() => {});
+}
+
 /** Merge a patch onto the RAW on-disk config and persist. The `build` callback
  *  receives the raw config so partial updates (subagents/roles maps) are derived
- *  from on-disk state, never from the env-overlaid runtime config. */
+ *  from on-disk state, never from the env-overlaid runtime config. The whole
+ *  read→merge→write cycle holds the global config lock so concurrent patches
+ *  (per-provider OAuth refreshes, /model save, doctor sweeps) never lose updates. */
 export async function saveConfigPatch(build: (raw: Config) => Partial<Config>): Promise<Config> {
-  const raw = await readRawGlobalConfig();
-  const next = { ...raw, ...build(raw) };
-  await saveGlobalConfig(next);
-  return next;
+  await acquireConfigLock();
+  try {
+    const raw = await readRawGlobalConfig();
+    const next = { ...raw, ...build(raw) };
+    await saveGlobalConfig(next);
+    return next;
+  } finally {
+    await releaseConfigLock();
+  }
 }
 
 export function getLocalJeoDir(cwd: string = process.cwd()): string {

package/src/agent/task-tool.ts

@@ -220,6 +220,9 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
       model,
       maxSteps,
       maxTokens: resolveMaxOutputTokens(model, thinking),
+      // Per-run prompt-cache key: the subagent replays its own growing history each
+      // step, so a stable per-run key gets provider cache hits (gjc sub-session parity).
+      sessionKey: crypto.randomUUID(),
       // Bounded delegation: a subagent's step contract stays exact — the parent
       // owns any retry/extension decision, so the gjc retry flow is disabled here.
       budget: { maxExtensions: 0 },

package/src/ai/model-catalog.ts

@@ -93,6 +93,14 @@ export const MODEL_CATALOG: readonly CatalogModel[] = [
   { canonical: "kimi-thinking-preview", provider: "kimi", providerModel: "kimi-thinking-preview", contextTokens: 128_000, maxOutputTokens: 32_000, thinking: FULL, images: true },
   { canonical: "kimi-latest", provider: "kimi", providerModel: "kimi-latest", contextTokens: 128_000, maxOutputTokens: 16_384, thinking: [], images: true },
   { canonical: "moonshot-v1-128k", provider: "kimi", providerModel: "moonshot-v1-128k", contextTokens: 128_000, maxOutputTokens: 16_384, thinking: [], images: false },
+  // Kimi Code (Moonshot coding subscription, device-code OAuth) — Anthropic-compatible
+  // at https://api.kimi.com/coding. Provider-qualified (`kimi/…`) to avoid canonical
+  // collisions (kimi-k2.5 also exists under tencent). gjc catalog parity: kimi-code.
+  { canonical: "kimi-for-coding", provider: "kimi", providerModel: "kimi/kimi-for-coding", contextTokens: 262_144, maxOutputTokens: 32_000, thinking: FULL, images: true, company: "Moonshot (Kimi Code)" },
+  { canonical: "kimi-k2.7-code", provider: "kimi", providerModel: "kimi/kimi-k2.7-code", contextTokens: 262_144, maxOutputTokens: 65_536, thinking: FULL, images: true, company: "Moonshot (Kimi Code)" },
+  { canonical: "kimi/kimi-k2.5", provider: "kimi", providerModel: "kimi/kimi-k2.5", contextTokens: 262_144, maxOutputTokens: 65_536, thinking: FULL, images: true, company: "Moonshot (Kimi Code)" },
+  { canonical: "kimi/kimi-k2-turbo-preview", provider: "kimi", providerModel: "kimi/kimi-k2-turbo-preview", contextTokens: 262_144, maxOutputTokens: 32_000, thinking: FULL, images: false, company: "Moonshot (Kimi Code)" },
+  { canonical: "kimi/kimi-k2", provider: "kimi", providerModel: "kimi/kimi-k2", contextTokens: 262_144, maxOutputTokens: 262_144, thinking: [], images: false, company: "Moonshot (Kimi Code)" },
   // Google
   { canonical: "gemini-1.5-pro", provider: "gemini", providerModel: "gemini-1.5-pro", contextTokens: 1_000_000, maxOutputTokens: 8_192, thinking: [], images: true },
   { canonical: "gemini-2.0-flash", provider: "gemini", providerModel: "gemini-2.0-flash", contextTokens: 1_000_000, maxOutputTokens: 8_192, thinking: [], images: true },
@@ -144,6 +152,21 @@ export const MODEL_CATALOG: readonly CatalogModel[] = [
  */
 export const CODEX_MODELS: readonly string[] = ["gpt-5.5", "gpt-5.4"];
 
+/**
+ * Model ids the Kimi Code OAuth backend (api.kimi.com/coding, Anthropic Messages
+ * format) actually serves. The subscription endpoint rejects Moonshot API-platform
+ * ids (kimi-latest, moonshot-v1-*, kimi-thinking-preview), so a Kimi OAuth login is
+ * limited to exactly these; an API key serves the api.moonshot.ai catalog instead.
+ * gjc parity: models.json `kimi-code` provider entries (wire ids, `kimi/` stripped).
+ */
+export const KIMI_CODE_MODELS: readonly string[] = [
+  "kimi-for-coding",
+  "kimi-k2.7-code",
+  "kimi-k2.5",
+  "kimi-k2-turbo-preview",
+  "kimi-k2",
+];
+
 /** Format a token count compactly (1000 → 1K, 1_000_000 → 1M). */
 export function formatTokens(n: number): string {
   if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(n % 1_000_000 === 0 ? 0 : 1)}M`;

package/src/ai/model-discovery.ts

@@ -11,7 +11,7 @@ import { readGlobalConfig, type Config } from "../agent/state";
 import { resolveCredential, type AuthProvider, type Credential } from "../auth";
 import type { ProviderName } from "./types";
 import { PROVIDER_NAMES } from "./provider-status";
-import { catalogByProvider, CODEX_MODELS } from "./model-catalog";
+import { catalogByProvider, CODEX_MODELS, KIMI_CODE_MODELS } from "./model-catalog";
 import { extractChatgptAccountId } from "./providers/openai-responses";
 import { openaiCompatDef } from "./providers/openai-compatible-catalog";
 
@@ -291,7 +291,11 @@ export function catalogOr(result: ProviderModelsResult): ProviderModelsResult {
   if (!eligible) return result;
   const ids = result.provider === "openai" && result.source === "oauth"
     ? [...CODEX_MODELS]
-    : catalogByProvider(result.provider).map(m => m.providerModel);
+    : result.provider === "kimi" && result.source === "oauth"
+      // Kimi OAuth (Kimi Code subscription) serves ONLY the Kimi Code catalog —
+      // moonshot API-platform ids would 404 against api.kimi.com/coding.
+      ? KIMI_CODE_MODELS.map(id => `kimi/${id}`)
+      : catalogByProvider(result.provider).map(m => m.providerModel);
   if (ids.length === 0) return result;
   return { ...result, models: ids, ok: true, fallback: true };
 }

package/src/ai/model-manager.ts

@@ -6,7 +6,7 @@ import "./register-providers"; // side-effect: registers built-in adapters into
 import type { CallOptions, Message, ProviderAdapter, ProviderName } from "./types";
 import { expandAlias, resolveModelId, effectiveAliasesFor } from "./model-registry";
 import { findCatalogEntry, type ModelCatalogEntry } from "./model-catalog-compat";
-import { toProviderModel, CODEX_MODELS, findCatalogModel } from "./model-catalog";
+import { toProviderModel, CODEX_MODELS, KIMI_CODE_MODELS, findCatalogModel } from "./model-catalog";
 import { xaiCredential } from "./providers/xai";
 import { OPENAI_COMPAT_NAMES, isOpenAICompatProvider } from "./providers/openai-compatible-catalog";
 import { withRetry, defaultRetryable, type RetryOptions } from "../util/retry";
@@ -194,19 +194,18 @@ const ALIAS_DEFAULTS = { fast: "ollama/qwen2.5:0.5b", local: "ollama/qwen2.5:0.5
  * requestMaxRetries + 1. When unset, the `withRetry` defaults apply (3 attempts),
  * but rate-limit (429) errors get a more generous budget + a backoff floor so a
  * transient per-minute window can clear instead of the very first 429 instantly
- * exhausting auto-retry. A server-directed retry delay above the five-minute
- * budget is surfaced immediately with its reset hint instead of being capped and
- * retried pointlessly. Explicit config (`requestMaxRetries`/`maxDelayMs`) always
- * wins and disables the matching rate-limit default.
- * `maxDelayMs` caps per-attempt backoff when provided.
+ * exhausting auto-retry. A server-directed retry delay is honored IN FULL — no
+ * default ceiling — because a generic 429 is retried forever, not treated as fatal
+ * past some arbitrary budget (gjc parity: even a multi-hour Anthropic rate-limit
+ * window is retried, not bailed on); `rateLimitMaxServerDelayMs` remains available
+ * as an explicit opt-in for a caller that truly cannot wait that long. Explicit
+ * config (`requestMaxRetries`/`maxDelayMs`) always wins and disables the matching
+ * rate-limit default. `maxDelayMs` caps per-attempt backoff when provided.
  */
 const DEFAULT_RATE_LIMIT_RETRIES = 6; // total attempts for 429 (initial + 5 retries)
 // 429 floor when the server sends no Retry-After. Escalates per attempt inside
 // withRetry (2s → 4s → 8s → 16s → 30s ≈ 60s total), spanning a per-minute window.
 const DEFAULT_RATE_LIMIT_MIN_DELAY_MS = 2000;
-// GJC parity for server-directed 429s: retry short windows, but do not hang a CLI
-// through long subscription/account resets.
-const DEFAULT_RATE_LIMIT_MAX_SERVER_DELAY_MS = 5 * 60 * 1000;
 export function resolveRetryOptions(retry: Config["retry"], kind: "request" | "stream" = "request"): RetryOptions {
   const opts: RetryOptions = { isRetryable: defaultRetryable };
 
@@ -244,7 +243,12 @@ export function resolveRetryOptions(retry: Config["retry"], kind: "request" | "s
   // 429 backoff floor: explicit wins; else default UNLESS the user pinned maxDelayMs.
   if (typeof retry?.rateLimitMinDelayMs === "number") opts.rateLimitMinDelayMs = retry.rateLimitMinDelayMs;
   else if (typeof retry?.maxDelayMs !== "number") opts.rateLimitMinDelayMs = DEFAULT_RATE_LIMIT_MIN_DELAY_MS;
-  opts.rateLimitMaxServerDelayMs = DEFAULT_RATE_LIMIT_MAX_SERVER_DELAY_MS;
+  // No default `rateLimitMaxServerDelayMs` ceiling: gjc parity retries a generic 429
+  // forever, honoring however long the server asks (see the doc comment above). Usage
+  // limits fail fast on their own via isUsageLimitError → defaultRetryable, well before a
+  // wait is ever computed, so this is safe. An explicit config value is still honored for
+  // a caller that truly cannot wait an unbounded server-directed delay.
+  if (typeof retry?.rateLimitMaxServerDelayMs === "number") opts.rateLimitMaxServerDelayMs = retry.rateLimitMaxServerDelayMs;
 
   // Config-driven fail-fast overrides: a status in `failFastStatuses` or a message
   // matching any `failFastPattern` is forced non-retryable, layered on top of the
@@ -281,12 +285,18 @@ export function resolveRetryOptions(retry: Config["retry"], kind: "request" | "s
 /**
  * Whether the bundled adapter can serve this provider+model over OAuth end-to-end.
  * OpenAI OAuth (ChatGPT/Codex) only serves Codex models, so any other OpenAI model
- * must use an API key. A provider whose OAuth backend is not verified end-to-end
+ * must use an API key. Kimi OAuth (Kimi Code subscription) only serves the Kimi Code
+ * catalog (api.kimi.com/coding) — Moonshot API-platform ids (kimi-latest, moonshot-v1-*)
+ * need a KIMI_API_KEY. A provider whose OAuth backend is not verified end-to-end
  * cannot serve any model over OAuth. Everything else (Anthropic Messages, Gemini /
  * Antigravity Cloud Code Assist) is served end-to-end.
  */
 function oauthServesModel(provider: AuthProvider, model: string): boolean {
   if (provider === "openai") return CODEX_MODELS.includes(model);
+  if (provider === "kimi") {
+    const wire = model.startsWith("kimi/") ? model.slice(5) : model;
+    return KIMI_CODE_MODELS.includes(wire);
+  }
   if (isOAuthProvider(provider) && OAUTH_FLOW_REGISTRY[provider].verifiedEndToEnd === false) return false;
   return true;
 }
@@ -375,6 +385,7 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
     onReasoning: options.onReasoning,
     onReasoningArtifact: options.onReasoningArtifact,
     tools: options.tools,
+    sessionKey: options.sessionKey,
   };
   // Caller-supplied retry sink rides on the config-derived retry budget so the
   // engine/TUI can surface "rate limited — retrying in Ns" instead of a silent wait.
@@ -383,7 +394,12 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
   // never replays after the first emitted chunk). Both fall back to `maxRetries`,
   // and an unset stream budget keeps the conservative withRetry default — the
   // generous gjc default of 100 only applies when the user configures it.
-  const retry: RetryOptions = { ...resolveRetryOptions(config.retry, kind), ...(options.onRetry ? { onRetry: options.onRetry } : {}) };
+  // `retry.signal` is the caller's ORIGINAL signal (Ctrl-C / turn abort) — not the
+  // per-attempt fetch timeout composed below — so a long, honored server-directed
+  // retry wait (see resolveRetryOptions) can still be cancelled by the user without
+  // waiting out the full delay, while a single attempt's timeout never cuts short
+  // the NEXT attempt's backoff sleep.
+  const retry: RetryOptions = { ...resolveRetryOptions(config.retry, kind), ...(options.onRetry ? { onRetry: options.onRetry } : {}), ...(callOptions.signal ? { signal: callOptions.signal } : {}) };
 
   if (provider === "ollama" || provider === "lmstudio") {
     return { adapter, callOptions, credential: { kind: "none", provider: "openai" }, retry };
@@ -416,6 +432,11 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
       "OpenAI OAuth 자격증명은 Codex 모델(gpt-5.5/gpt-5.4)만 지원. OPENAI_API_KEY를 설정하거나 모델을 변경하세요"
     );
   }
+  if (provider === "kimi" && effective.kind === "oauth" && !oauthServesModel("kimi", model)) {
+    throw new Error(
+      `Kimi OAuth (Kimi Code subscription) serves only the Kimi Code models (${KIMI_CODE_MODELS.join(", ")}). Set KIMI_API_KEY for Moonshot API models, or pick a Kimi Code model with /model.`,
+    );
+  }
   if (effective.kind === "none" && !isLocalOpenAi) {
     throw new Error(
       `No credential for provider '${provider}'. Run 'jeo setup', 'jeo auth login', or set ${provider.toUpperCase()}_API_KEY / ${provider.toUpperCase()}_OAUTH_TOKEN.`

package/src/ai/providers/anthropic.ts

@@ -12,9 +12,14 @@ const CLAUDE_CODE_VERSION = "2.1.63";
 const CLAUDE_CODE_SYSTEM_INSTRUCTION = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
 const CLAUDE_BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
 /** Betas needed for API-key requests: interleaved-thinking enables thinking+tools,
- *  prompt-caching-scope gives scoped cache breakpoints. */
+ *  context-management matches gjc's default beta set (sent on ALL requests),
+ *  prompt-caching-scope gives scoped cache breakpoints.
+ *  ponytail: fine-grained-tool-streaming-2025-05-14 — gjc sends it and repairs truncated
+ *  tool-argument JSON; jeo parses accumulated tool JSON without that repair pass, so the
+ *  beta stays off until a repair step exists. */
 const ANTHROPIC_API_KEY_BETA = [
   "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
   "prompt-caching-scope-2026-01-05",
 ];
 const ANTHROPIC_OAUTH_BETA = [
@@ -46,8 +51,10 @@ function stripAnthropicPrefix(model: string): string {
   return model.startsWith("anthropic/") ? model.slice(10) : model;
 }
 
-function shouldUseClaudeCodeOAuthShape(model: string, credential: Credential): boolean {
-  return credential.kind === "oauth" && !model.startsWith("claude-3-5-haiku");
+function shouldUseClaudeCodeOAuthShape(model: string, credential: Credential, baseUrl?: string): boolean {
+  // Claude-Code OAuth cloaking is for api.anthropic.com only. An OAuth credential
+  // against a custom base (e.g. Kimi Code at api.kimi.com/coding) is a plain bearer.
+  return credential.kind === "oauth" && !baseUrl && !model.startsWith("claude-3-5-haiku");
 }
 
 function createClaudeCloakingUserId(): string {
@@ -68,9 +75,10 @@ function anthropicSystemBlocks(
   model: string,
   credential: Credential,
   billingPayload: Record<string, unknown>,
+  baseUrl?: string,
 ): AnthropicSystemBlock[] | undefined {
   const blocks: AnthropicSystemBlock[] = [];
-  if (shouldUseClaudeCodeOAuthShape(model, credential)) {
+  if (shouldUseClaudeCodeOAuthShape(model, credential, baseUrl)) {
     const billingSeed = systemPrompt ? { ...billingPayload, system: [systemPrompt] } : billingPayload;
     blocks.push(
       { type: "text", text: createClaudeBillingHeader(billingSeed) },
@@ -89,17 +97,19 @@ function anthropicSystemBlocks(
   return blocks;
 }
 
-/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Cross-provider
- *  parity (matches Gemini's tiers): minimal/low/medium/high ALL enable thinking with scaling
+/** Anthropic extended-thinking budget by reasoning effort (kept under max_tokens). Tiers match
+ *  gjc's ANTHROPIC_THINKING table: minimal/low/medium/high ALL enable thinking with scaling
  *  depth — reasoning works at every thinking level (gajae parity: Minimal is a real effort).
- *  Only an UNSET effort stays non-thinking (the explicit /fast off path). */
-function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"], maxTokens: number): number | undefined {
+ *  Only an UNSET effort stays non-thinking (the explicit /fast off path). The "xhigh" row is
+ *  correct-by-table even though upstream currently folds xhigh→high before it arrives. */
+function anthropicThinkingBudget(effort: CallOptions["reasoningEffort"] | "xhigh", maxTokens: number): number | undefined {
   let budget: number;
   switch (effort) {
-    case "minimal": budget = 2000; break;
-    case "low": budget = 4000; break;
-    case "medium": budget = 10000; break;
-    case "high": budget = 24000; break;
+    case "minimal": budget = 1024; break;
+    case "low": budget = 4096; break;
+    case "medium": budget = 8192; break;
+    case "high": budget = 16384; break;
+    case "xhigh": budget = 32768; break;
     default: return undefined;
   }
   return Math.min(budget, Math.max(1024, maxTokens - 1024));
@@ -264,7 +274,7 @@ export function anthropicPayload(
     // Extended thinking requires max_tokens strictly above the thinking budget.
     max_tokens: thinkingBudget !== undefined ? Math.max(maxTokens, thinkingBudget + 1024) : maxTokens,
   };
-  if (credential.kind === "oauth") payload.metadata = { user_id: createClaudeCloakingUserId() };
+  if (shouldUseClaudeCodeOAuthShape(model, credential, options.baseUrl)) payload.metadata = { user_id: createClaudeCloakingUserId() };
   if (effort !== undefined) {
     // Enable Claude extended thinking. Extended thinking forbids a custom temperature, so
     // temperature is only set on the non-thinking path.
@@ -294,7 +304,7 @@ export function anthropicPayload(
     payload.tool_choice = { type: "auto" };
   }
   if (stream) payload.stream = true;
-  const system = anthropicSystemBlocks(systemPrompt, model, credential, payload);
+  const system = anthropicSystemBlocks(systemPrompt, model, credential, payload, options.baseUrl);
   if (system) payload.system = system;
   return JSON.stringify(payload);
 }
@@ -311,7 +321,7 @@ export function anthropicRequest(
     // Anthropic-compatible providers (z.ai, MiniMax, …) accept the Messages wire
     // format at their own host; an explicit baseUrl pins `${base}/v1/messages`.
     url: options.baseUrl ? `${options.baseUrl.replace(/\/$/, "")}/v1/messages` : ANTHROPIC_URL,
-    headers: headersFor(credential, stream, stripAnthropicPrefix(options.model)),
+    headers: { ...headersFor(credential, stream, stripAnthropicPrefix(options.model), options.baseUrl), ...options.extraHeaders },
     body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts),
   };
 }
@@ -327,6 +337,22 @@ function isReasoningArtifactError(status: number, detail: string): boolean {
   return status === 400 && /thinking|signature|redacted_thinking/i.test(detail);
 }
 
+/** gjc parity (getSafeAnthropicHeaderEvidence): fold Anthropic's rate-limit response
+ *  headers into a 429's error detail so the retry classifier can see them. The decisive
+ *  usage-exhaustion signal (`anthropic-ratelimit-unified-overage-disabled-reason:
+ *  out_of_credits`) often arrives ONLY as a header — without this, an out-of-credits 429
+ *  reads like a generic per-minute rate limit and is retried pointlessly. */
+function anthropicRateLimitEvidence(headers: Headers): string {
+  const evidence: string[] = [];
+  for (const [name, value] of headers) {
+    const lower = name.toLowerCase();
+    if (lower === "retry-after" || lower === "retry-after-ms" || lower.startsWith("anthropic-ratelimit-")) {
+      evidence.push(`${lower}=${value}`);
+    }
+  }
+  return evidence.length > 0 ? ` Anthropic rate-limit evidence: ${evidence.sort().join(", ")}` : "";
+}
+
 async function postAnthropic(
   messages: Message[],
   options: CallOptions,
@@ -354,10 +380,13 @@ async function postAnthropic(
     throw await providerHttpError("Anthropic", response, stream ? "(stream)" : undefined);
   }
 
+  // 429s carry their rate-limit headers in the DETAIL so isUsageLimitError /
+  // friendlyProviderError can classify on the full evidence (gjc parity).
+  const enrichedDetail = response.status === 429 ? `${detail}${anthropicRateLimitEvidence(response.headers)}` : detail;
   throw new ProviderHttpError(
     "Anthropic",
     response.status,
-    detail,
+    enrichedDetail,
     stream ? "(stream)" : undefined,
     parseRetryAfter(response.headers.get("retry-after")) ?? parseRetryFromBody(detail),
   );
@@ -543,8 +572,18 @@ function claudeCodeOAuthHeaders(stream: boolean, model: string): Record<string,
   };
 }
 
-function headersFor(credential: Credential, stream: boolean, model: string): Record<string, string> {
+function headersFor(credential: Credential, stream: boolean, model: string, baseUrl?: string): Record<string, string> {
   if (credential.kind === "oauth") {
+    // OAuth against a NON-Anthropic base (Kimi Code, …): plain bearer, no Claude-Code
+    // cloaking headers/betas. gjc parity: buildAnthropicHeaders' generic-bearer branch.
+    if (baseUrl) {
+      return {
+        accept: stream ? "text/event-stream" : "application/json",
+        "content-type": "application/json",
+        authorization: `Bearer ${credential.token}`,
+        "anthropic-version": "2023-06-01",
+      };
+    }
     return {
       "content-type": "application/json",
       authorization: `Bearer ${credential.token}`,