jeo-code 0.7.8 → 0.7.10

package/CHANGELOG.md

@@ -6,6 +6,23 @@ 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.9] - 2026-06-24
+_Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch._
+
+### Added
+- **Ollama requests send an explicit `num_ctx` so the prompt fits the loaded window.** Ollama loads a model with its small *server* default context (~2048/4096), ignoring the model's advertised `context_length`, unless the request supplies `num_ctx` — so jeo's large system prompt (tool protocol + AGENTS context) overflowed it and every turn died with HTTP 400 "the conversation no longer fits the model's context window." `resolveOllamaNumCtx` (`src/ai/providers/ollama.ts`) now resolves a window with precedence per-call/config → `OLLAMA_NUM_CTX` → `OLLAMA_CONTEXT_LENGTH` → `16384` default (zero/negative/non-numeric ignored) and threads it onto the `/api/chat` `options`. New `ollamaNumCtx` config field (`src/agent/state.ts`, `config-schema.ts`) + `numCtx` `CallOptions` (`src/ai/types.ts`) wired through `model-manager.ts`. The previously-missing `lmstudioBaseUrl` schema key is added too.
+- **Stale `jeo` tmux REPL sessions are reaped on launch.** Each detached, long-idle `jeo launch` REPL pins tens of MB forever, so over days they pile up and aggregate RSS climbs. `selectReapableTmuxSessions`/`reapStaleTmuxSessions` (`src/commands/launch/tmux.ts`) sweep only jeo-owned (`@jeo-profile` marker), unattached, long-idle sessions — never the one just created — on each launch; opt out with `JEO_TMUX_REAP=0`. Abandoned REPLs persist their transcript to `.jeo/sessions/` and stay `--resume`-able, so reaping discards only the dead in-memory view.
+
+### Fixed
+- **LM Studio reasoning replies on the `reasoning` channel are recovered instead of dying empty.** Local OpenAI-compatible servers (LM Studio, …) running reasoning models routinely emit the WHOLE reply — including the `{"tool":…}` JSON — into `reasoning_content`/`reasoning` while leaving `content` empty, which otherwise died as a "returned no content" turn. The OpenAI adapter now recovers the answer from the reasoning channel (stripping leaked reasoning/tool-call scaffolding) before failing.
+- **GGUF chat templates that can't render the `tools` array are retried with native tools stripped.** A jinja template error from passing the `tools` array (a common LM Studio 400) is detected (`isUnsupportedToolsError`) and the call is retried with native tools removed (`stripNativeTools`), falling back to JSON-in-prose tool calling. The strip path deliberately does *not* inject `response_format: json_object` (LM Studio rejects it — only `json_schema`/`text`).
+- **The effective-credential picker prefers a verified OAuth login over a stray API key.** `effectiveCredential` (`src/ai/provider-status.ts`) now keeps the user's explicit OAuth login as the working path whenever the bundled adapter serves it end-to-end; an API key only wins for OpenAI OAuth (Codex-only) or an OAuth backend not yet verified end-to-end — mirroring the real call path instead of always letting the API key shadow OAuth.
+- **The OAuth success tab auto-closes with a clear "you can close" hint.** The login-complete callback page now shows a 3-second countdown and calls `window.close()` (`src/auth/callback-server.ts`), with an explicit manual-close hint for OS-launched tabs the script can't close, and a clearer "return to the terminal — jeo is ready" message.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 1952 pass / 0 fail across 232 files — including the new `test/ollama-num-ctx.test.ts` (`num_ctx` precedence + on-wire send), `test/openai-unsupported-tools.test.ts`, `test/provider-empty-completion.test.ts`, `test/tmux-reap.test.ts`, and updated provider-status/oauth/model-manager suites. Live Ollama probe confirmed: a ~6000-token prompt that returned HTTP 400 under the default window now succeeds with the explicit `num_ctx`.
+
+
 ## [0.7.8] - 2026-06-24
 _Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach._
 

package/README.ja.md

@@ -193,11 +193,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
-- **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -193,11 +193,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
-- **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -195,11 +195,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.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
-- **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -193,11 +193,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
 - **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
 - **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 - **[0.7.5]** (2026-06-23) — Startup & loop latency: redundant re-reads that fired on every subagent spawn and every loop step are now memoized behind cheap `stat`-signature caches, so cold paths stay correct (edits/deletes still picked up immediately) while warm paths skip the disk and the re-parse. Targets the per-turn and per-spawn overhead that dominates perceived slowness in team/ralph/autopilot fan-outs.
-- **[0.7.4]** (2026-06-22) — Per-session model isolation + REPL slash-handler testability: a running `jeo` session now pins the model it resolved at start, so a concurrent session running `/model` (which persists the global default) can no longer silently switch a different live session's model mid-run. The read-only code-inspection slashes (`/view`, `/diff`, `/find`, `/search`), the `/undo` git slash, and the `/history` view are extracted into pure, PTY-free handlers so their logic is unit-tested directly instead of buried in the REPL loop.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/config-schema.ts

@@ -68,7 +68,9 @@ export const ConfigSchema = z
       })
       .optional(),
     ollamaBaseUrl: z.string().optional(),
+    ollamaNumCtx: z.number().int().positive().optional(),
     openaiBaseUrl: z.string().optional(),
+    lmstudioBaseUrl: z.string().optional(),
     defaultModel: z.string().min(1),
     theme: z.string().optional(),
     thinkingLevel: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional(),

package/src/agent/state.ts

@@ -39,6 +39,8 @@ export interface Config {
   oauth?: Partial<Record<AuthProvider, string | StoredOAuth>>;
   /** Base URL for the local Ollama server (keyless). */
   ollamaBaseUrl?: string;
+  /** Ollama context window (`num_ctx`); overrides the server's small default. Env: OLLAMA_NUM_CTX. */
+  ollamaNumCtx?: number;
   /** Base URL override for OpenAI-compatible providers (vLLM, llama-cpp-server, ...). */
   openaiBaseUrl?: string;
   /** Base URL for the local LM Studio server (keyless, OpenAI-compatible). */

package/src/agent/tool-output.ts

@@ -83,7 +83,7 @@ export async function spillToolResult(tool: string, output: string, cwd: string)
   await fs.mkdir(dir, { recursive: true });
   const safeTool = tool.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 32) || "tool";
   const stamp = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const rel = path.join(".jeo", "artifacts", "tool-results", `${stamp}-${safeTool}.txt`);
+  const rel = `.jeo/artifacts/tool-results/${stamp}-${safeTool}.txt`;
   await fs.writeFile(path.join(cwd, rel), output, "utf-8");
   // Retention so a long session can't grow the artifact dir without bound.
   await pruneToolArtifacts(dir);

package/src/agent/tools.ts

@@ -805,7 +805,7 @@ async function spawnTextWithTimeout(
   timeoutMs = 60_000,
 ): Promise<{ stdout: string; stderr: string; exitCode: number | null; timedOut: boolean }> {
   // stdin detached so a command that reads stdin gets EOF instead of blocking.
-  const proc = Bun.spawn(cmd, { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  const proc = Bun.spawn(cmd, { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe", env: { ...process.env, MSYS: "noglob" } });
   let timedOut = false;
   let killTimer: ReturnType<typeof setTimeout> | undefined;
   const stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as ReadableStreamDefaultReader<Uint8Array>;
@@ -863,7 +863,8 @@ export async function findTool(
       const prunedDirs = new Set([...IGNORED_DIRS, ...gi.dirs]);
       const fileGlobs = gi.fileGlobs.map(g => new Bun.Glob(g));
       const matches: string[] = [];
-      for await (const rel of new Bun.Glob(globPattern).scan({ cwd, onlyFiles: true })) {
+      for await (const rawRel of new Bun.Glob(globPattern).scan({ cwd, onlyFiles: true })) {
+        const rel = rawRel.replace(/\\/g, "/");
         const segs = rel.split("/");
         if (segs.some(seg => prunedDirs.has(seg))) continue;
         const base = segs[segs.length - 1] ?? rel;

package/src/ai/model-manager.ts

@@ -252,12 +252,25 @@ export function resolveRetryOptions(retry: Config["retry"], kind: "request" | "s
   return opts;
 }
 
+/**
+ * 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
+ * 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 (isOAuthProvider(provider) && OAUTH_FLOW_REGISTRY[provider].verifiedEndToEnd === false) return false;
+  return true;
+}
+
 /**
  * Pick the credential to actually use for a provider call / live discovery.
- * An API key is the broader, documented path, so it wins whenever present.
- * Every bundled OAuth flow is now served end-to-end (Anthropic Messages,
- * OpenAI ChatGPT/Codex Responses, Gemini/Antigravity Cloud Code Assist); the
- * guard below only fires for a future flow that ships before its adapter.
+ * OAuth is the user's explicit login, so it wins whenever the bundled adapter can
+ * serve the requested model over OAuth — even when an API key is also configured
+ * (e.g. a leftover env var). Only when OAuth cannot serve the model do we fall back
+ * to the API key, and only then surface the OAuth-incompatibility error.
  */
 export function effectiveCredentialForProvider(
   provider: AuthProvider,
@@ -266,6 +279,7 @@ export function effectiveCredentialForProvider(
   model: string,
 ): Credential {
   if (credential.kind === "oauth") {
+    if (oauthServesModel(provider, model)) return credential;
     const apiKey = config.providers[provider];
     if (apiKey) return { kind: "api_key", provider, token: apiKey };
     if (isOAuthProvider(provider) && OAUTH_FLOW_REGISTRY[provider].verifiedEndToEnd === false) {
@@ -328,6 +342,7 @@ async function resolveCall(options: Partial<CallOptions>, kind: "request" | "str
     maxTokens: options.maxTokens ?? thinkingMaxTokens(config.thinkingLevel),
     jsonMode: options.jsonMode,
     baseUrl,
+    numCtx: options.numCtx ?? (provider === "ollama" ? (config as { ollamaNumCtx?: number }).ollamaNumCtx : undefined),
     onUsage: options.onUsage,
     signal: options.signal,
     reasoningEffort: options.reasoningEffort ?? thinkingToReasoningEffort(config.thinkingLevel),
@@ -518,7 +533,8 @@ export function streamIdleMs(env?: Record<string, string | undefined>): number {
  *  built-in default. Mirrors streamIdleMs so a slow non-interactive turn (callLlm without
  *  onToken) can relax the cap via JEO_CALL_TIMEOUT_MS without a code change. */
 export function callTimeoutMs(env?: Record<string, string | undefined>): number {
-  const raw = jeoEnv("CALL_TIMEOUT_MS", env);
+  const e = env ?? process.env;
+  const raw = jeoEnv("CALL_TIMEOUT_MS", e) ?? e["ANTHROPIC_TIMEOUT"];
   const n = raw !== undefined ? parseInt(raw, 10) : NaN;
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_CALL_TIMEOUT_MS;
 }

package/src/ai/provider-status.ts

@@ -81,11 +81,17 @@ function configuredCredential(provider: AuthProvider, cfg: Config): Credential {
   return { kind: "none", provider };
 }
 
-/** Match the real call path: API keys are broader and win whenever both key + OAuth exist. */
+/** Mirror the real call path: OAuth (the user's explicit login) wins whenever the
+ * bundled adapter serves it end-to-end. OpenAI OAuth only serves Codex models, and an
+ * OAuth backend not verified end-to-end can't serve calls, so an API key stays the
+ * working path in those cases — otherwise the stored OAuth credential is preferred. */
 function effectiveCredential(provider: AuthProvider, cred: Credential, cfg: Config): Credential {
   const key = cfg.providers?.[provider];
-  if (cred.kind === "oauth" && key) return { kind: "api_key", provider, token: key };
-  return cred;
+  if (cred.kind !== "oauth" || !key) return cred;
+  const oauthGeneral =
+    provider !== "openai" &&
+    !(isOAuthProvider(provider) && OAUTH_FLOW_REGISTRY[provider].verifiedEndToEnd === false);
+  return oauthGeneral ? cred : { kind: "api_key", provider, token: key };
 }
 
 

package/src/ai/providers/ollama.ts

@@ -13,6 +13,26 @@ export function normalizeOllamaBaseUrl(baseUrl?: string): string {
   return (/^https?:\/\//i.test(v) ? v : `http://${v}`).replace(/\/$/, "");
 }
 
+/**
+ * Default Ollama context window when the prompt would otherwise overflow.
+ *
+ * Ollama loads every model with a SERVER default `num_ctx` (historically 2048/4096),
+ * IGNORING the model's advertised `context_length`, unless the request supplies one.
+ * jeo's system prompt + tool protocol + AGENTS context routinely exceeds that, so the
+ * request 400s with "context window" even for a model that natively supports 128k.
+ * We therefore send an explicit `num_ctx`. Precedence: per-call/config value →
+ * `OLLAMA_NUM_CTX`/`OLLAMA_CONTEXT_LENGTH` env → a sane 16384 default. Lower it on
+ * memory-constrained hosts (KV-cache is allocated for the full window).
+ */
+export const DEFAULT_OLLAMA_NUM_CTX = 16384;
+
+export function resolveOllamaNumCtx(explicit?: number): number {
+  if (typeof explicit === "number" && explicit > 0) return Math.floor(explicit);
+  const env = process.env.OLLAMA_NUM_CTX ?? process.env.OLLAMA_CONTEXT_LENGTH;
+  const parsed = env ? Number.parseInt(env, 10) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_OLLAMA_NUM_CTX;
+}
+
 function ollamaRequest(messages: Message[], options: CallOptions, stream: boolean): { url: string; body: string } {
   const model = options.model.startsWith("ollama/") ? options.model.slice(7) : options.model;
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
@@ -28,7 +48,7 @@ function ollamaRequest(messages: Message[], options: CallOptions, stream: boolea
     model,
     messages: chatMessages,
     stream,
-    options: { temperature: options.temperature ?? 0.2, num_predict: options.maxTokens ?? 4000 },
+    options: { temperature: options.temperature ?? 0.2, num_predict: options.maxTokens ?? 4000, num_ctx: resolveOllamaNumCtx(options.numCtx) },
   };
   if (options.jsonMode) payload.format = "json";
   const base = normalizeOllamaBaseUrl(options.baseUrl);

package/src/ai/providers/openai.ts

@@ -4,7 +4,7 @@ import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
-import { createThinkSplitter } from "../think-tags";
+import { createThinkSplitter, stripLeakedReasoningTags } from "../think-tags";
 
 /** True for OpenAI reasoning models (o-series + gpt-5+ family). Digit-count agnostic
  *  (gpt-6/o10 stay reasoning). Strips the `openai/` routing prefix first. */
@@ -57,17 +57,25 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
   // and reject temperature; classic chat models (gpt-4o, …) take max_tokens + temperature.
   // Digit-count agnostic (gpt-6/o10 stay reasoning) — mirrors inferCatalogMetadata.
   const isReasoning = isOpenAIReasoningModel(model);
+  // A custom baseUrl means a local / OpenAI-compatible backend (LM Studio, llama.cpp, vLLM,
+  // Ollama's OpenAI shim, …). Local reasoning models (DeepSeek-R1, Qwen3, …) routinely burn
+  // thousands of tokens INSIDE <think> before emitting the answer, so the cloud-tuned 4000
+  // default truncates them at finish_reason=length with an EMPTY content. There's no
+  // per-token cost locally, so give them real headroom to both think and answer.
+  const isLocalEndpoint = Boolean(options.baseUrl || (process.env.OPENAI_BASE_URL && !/\bapi\.openai\.com\b/.test(process.env.OPENAI_BASE_URL)));
+  const defaultMaxTokens = isLocalEndpoint ? 16000 : 4000;
   const payload: Record<string, unknown> = {
     model,
     messages: openaiMessages,
   };
   if (isReasoning) {
-    payload.max_completion_tokens = options.maxTokens ?? 4000;
+    payload.max_completion_tokens = options.maxTokens ?? defaultMaxTokens;
     if (options.reasoningEffort) payload.reasoning_effort = options.reasoningEffort;
   } else {
     payload.temperature = options.temperature ?? 0.2;
-    payload.max_tokens = options.maxTokens ?? 4000;
+    payload.max_tokens = options.maxTokens ?? defaultMaxTokens;
   }
+
   // gjc parity — enable NATIVE reasoning per the backend's thinking format so the model
   // actually emits reasoning (otherwise OpenRouter/Qwen/z.ai stay silent and the TUI has
   // nothing to show). `reasoning_effort` (OpenAI-style) only suits o-series/gpt-5; other
@@ -101,6 +109,82 @@ function emptyCompletionError(finishReason: string | undefined): Error {
   return new Error(`OpenAI returned no content${finishReason ? ` (finish_reason=${finishReason})` : ""}${hint}.`);
 }
 
+/** Scan `text` for the first BALANCED, syntactically valid JSON object that carries a
+ *  `tool`/`tools` key — i.e. a complete jeo tool envelope. Brace-depth aware and string/
+ *  escape safe so a `{` inside a JSON string never miscounts. Returns the raw object
+ *  substring, or "" if none is complete. Used to salvage a truncated (finish_reason=length)
+ *  reasoning stream when the model finished the actionable JSON before it ran out of budget. */
+function firstCompleteToolEnvelope(text: string): string {
+  for (let start = text.indexOf("{"); start !== -1; start = text.indexOf("{", start + 1)) {
+    let depth = 0, inStr = false, esc = false;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (esc) { esc = false; continue; }
+      if (ch === "\\") { esc = true; continue; }
+      if (ch === '"') { inStr = !inStr; continue; }
+      if (inStr) continue;
+      if (ch === "{") depth++;
+      else if (ch === "}" && --depth === 0) {
+        const candidate = text.slice(start, i + 1);
+        try {
+          const obj = JSON.parse(candidate) as Record<string, unknown>;
+          if (obj && (typeof obj.tool === "string" || Array.isArray(obj.tools))) return candidate;
+        } catch { /* not valid JSON — keep scanning from the next `{` */ }
+        break;
+      }
+    }
+  }
+  return "";
+}
+
+/** Recover a usable answer from the reasoning channel when `content` came back empty.
+ *  Local OpenAI-compatible servers (LM Studio, llama.cpp, …) running reasoning models
+ *  frequently route the ENTIRE reply — including the `{"tool":…}` JSON tool call — into
+ *  `reasoning_content`/`reasoning` (or an inline `<think>…</think>` block) and leave
+ *  `content` empty, which would otherwise kill the turn with "OpenAI returned no content".
+ *
+ *  Strips leaked think/scaffolding markup and returns the recovered text when the turn ended
+ *  normally (no `finish_reason`, or `stop`). On a `length` finish the reasoning is truncated,
+ *  but a thinking model often COMPLETES the JSON tool envelope before it runs out of budget —
+ *  so we still salvage that complete envelope when present, and otherwise surface the
+ *  actionable budget error. `content_filter` is never recovered (the reply was blocked).
+ *  Returns "" when nothing is recoverable. */
+function recoverFromReasoning(reasoning: string, finishReason: string | undefined): string {
+  if (!reasoning) return "";
+  if (finishReason === "content_filter") return "";
+  if (finishReason === "length") return firstCompleteToolEnvelope(reasoning);
+  return stripLeakedReasoningTags(reasoning);
+}
+
+/** A 400 caused by the request's `tools` array, not by the conversation. Many local
+ *  OpenAI-compatible servers (LM Studio, llama.cpp, older vLLM) ship GGUF chat templates
+ *  with no tool-calling support; given a `tools` array they fail to render the prompt
+ *  (LM Studio: `Error rendering prompt with jinja template …`) and 400 the whole turn.
+ *  jeo ALSO states the JSON-in-prose tool protocol in every system prompt, so we can drop
+ *  native tools and let the model drive tools via canonical JSON rather than dying. Gated
+ *  on the request actually carrying tools (a 400 without tools is a real error) plus an
+ *  error body that points at the template/tools/function machinery. */
+export function isUnsupportedToolsError(requestBody: string, errorBody: string): boolean {
+  let parsed: Record<string, unknown>;
+  try { parsed = JSON.parse(requestBody); } catch { return false; }
+  if (!Array.isArray(parsed.tools) || parsed.tools.length === 0) return false;
+  return /jinja|template|tool|function[_ ]?call|does not support|not supported/i.test(errorBody);
+}
+
+/** Rebuild an OpenAI request body with native tools removed so a backend whose chat
+ *  template can't render them stops 400ing. The model still returns a parseable tool
+ *  envelope via the JSON-in-prose protocol jeo states in every system prompt. We do NOT
+ *  inject `response_format: json_object` — some LM Studio builds reject it ("must be
+ *  'json_schema' or 'text'"), and the prompt already mandates strict JSON. Every other
+ *  field (stream, stream_options, messages, …) is preserved. */
+export function stripNativeTools(requestBody: string): string {
+  const parsed = JSON.parse(requestBody) as Record<string, unknown>;
+  delete parsed.tools;
+  delete parsed.tool_choice;
+  return JSON.stringify(parsed);
+}
+
+
 /** A streamed `choices[].delta`. `reasoning` is `unknown` because OpenAI-compatible
  *  servers disagree on its shape: a plain string (OpenRouter/xAI), an object
  *  `{ text|content }`, or absent (the `reasoning_details[]` array carries it instead). */
@@ -152,16 +236,34 @@ export const openaiAdapter: ProviderAdapter = {
       } catch { /* /responses unsupported for this model/account — fall through to chat */ }
     }
     const { url, headers, body } = openaiRequest(messages, options, credential, false);
-    const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+    let response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+    if (response.status === 400) {
+      // Local OpenAI-compatible servers (LM Studio, llama.cpp, …) 400 when a GGUF chat
+      // template can't render the `tools` array. Drop native tools and retry once — the
+      // model drives tools via the JSON-in-prose protocol jeo always states in the prompt.
+      const errBody = await response.clone().text().catch(() => "");
+      if (isUnsupportedToolsError(body, errBody)) {
+        response = await fetch(url, { method: "POST", headers, body: stripNativeTools(body), signal: options.signal });
+      }
+    }
     if (!response.ok) throw await providerHttpError("OpenAI", response);
-    const result = (await response.json()) as { choices: { message: { content?: string; tool_calls?: { function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+
+    const result = (await response.json()) as { choices: { message: { content?: string; reasoning_content?: string; reasoning?: string; tool_calls?: { function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
     if (result.usage) options.onUsage?.({ inputTokens: result.usage.prompt_tokens, outputTokens: result.usage.completion_tokens });
     // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
     const envelope = serializeToolCalls(parseOpenaiToolCalls(result.choices[0]?.message?.tool_calls));
     if (envelope) return envelope;
     const text = result.choices[0]?.message?.content ?? "";
-    if (!text) throw emptyCompletionError(result.choices[0]?.finish_reason);
-    return text;
+    if (text) return text;
+    // Recover from the reasoning channel before failing. LM Studio (and other local
+    // OpenAI-compatible servers) running reasoning models routinely emit the WHOLE reply —
+    // including the `{"tool":…}` JSON — into `reasoning_content`/`reasoning` while leaving
+    // `content` empty, which otherwise dies as a dead "returned no content" turn.
+    const finishReason = result.choices[0]?.finish_reason;
+    const msg = result.choices[0]?.message;
+    const recovered = recoverFromReasoning(msg?.reasoning_content ?? msg?.reasoning ?? "", finishReason);
+    if (recovered) return recovered;
+    throw emptyCompletionError(finishReason);
   },
   async *stream(messages, options, credential) {
     if (credential.kind === "oauth") {
@@ -191,15 +293,25 @@ export const openaiAdapter: ProviderAdapter = {
         const stripped = JSON.parse(body) as Record<string, unknown>;
         delete stripped.stream_options;
         response = await fetch(url, { method: "POST", headers, body: JSON.stringify(stripped), signal: options.signal });
+      } else if (isUnsupportedToolsError(body, errBody)) {
+        // A GGUF chat template that can't render the `tools` array (LM Studio jinja error).
+        // Drop native tools and retry once — the model drives tools via JSON-in-prose.
+        response = await fetch(url, { method: "POST", headers, body: stripNativeTools(body), signal: options.signal });
       }
     }
+
     if (!response.ok) throw await providerHttpError("OpenAI", response, "(stream)");
     if (!response.body) return;
     let yieldedAny = false;
     let finishReason: string | undefined;
+    // Mirror every reasoning delta into a local buffer so a content-less reply can be
+    // recovered from the reasoning channel at end-of-stream (see recoverFromReasoning).
+    let reasoningBuf = "";
+    const captureReasoning = (delta: string) => { reasoningBuf += delta; options.onReasoning?.(delta); };
     // Split inline <think>…</think> (DeepSeek-R1/Qwen-style local models) out of the
     // visible answer and onto the reasoning channel. No-op for models that never emit it.
-    const think = createThinkSplitter(options.onReasoning);
+    const think = createThinkSplitter(captureReasoning);
+
     const toolAcc = new Map<number, { name: string; args: string }>();
     for await (const data of readSse(response.body, options.onStreamActivity)) {
       let chunk: { choices?: { delta?: OpenAIDelta; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
@@ -220,7 +332,7 @@ export const openaiAdapter: ProviderAdapter = {
       // <think> splitter): handles string fields, an object `reasoning`, and the
       // `reasoning_details[]` array form (OpenRouter/xAI/DeepSeek variants).
       const reason = reasoningDeltaOf(chunk.choices?.[0]?.delta);
-      if (reason) options.onReasoning?.(reason);
+      if (reason) captureReasoning(reason);
       const tcs = chunk.choices?.[0]?.delta?.tool_calls;
       if (tcs) {
         for (const tc of tcs) {
@@ -239,7 +351,14 @@ export const openaiAdapter: ProviderAdapter = {
     // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
     const envelope = serializeAccumulatedToolCalls(toolAcc);
     if (envelope) { yieldedAny = true; yield envelope; }
-    if (!yieldedAny) throw emptyCompletionError(finishReason);
+    if (!yieldedAny) {
+      // Recover from the reasoning channel before failing the turn. Local reasoning models
+      // (LM Studio, llama.cpp, …) often stream the whole reply — JSON tool call included —
+      // as reasoning/<think> with an empty `content`.
+      const recovered = recoverFromReasoning(reasoningBuf, finishReason);
+      if (recovered) { yield recovered; return; }
+      throw emptyCompletionError(finishReason);
+    }
   },
 };
 

package/src/ai/types.ts

@@ -99,6 +99,9 @@ export interface CallOptions {
   jsonMode?: boolean;
   /** Per-call base URL override (OpenAI-compat / Ollama). */
   baseUrl?: string;
+  /** Ollama context window (`num_ctx`). Overrides the server's small default so jeo's
+   *  large system prompt fits; ignored by non-Ollama providers. */
+  numCtx?: number;
   /** Optional sink for provider-reported token usage. */
   onUsage?: (usage: Usage) => void;
   /** Abort in-flight provider requests (Ctrl-C / timeout / supersede). */

package/src/auth/callback-server.ts

@@ -27,16 +27,30 @@ export interface OAuthCallbackFlowOptions {
 
 export type CallbackResult = { code: string; state: string };
 
-const SUCCESS_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>jeo — login complete</title>
+const PAGE_HTML = `<!doctype html><html><head><meta charset="utf-8"><title>jeo — login complete</title>
 <style>body{font-family:system-ui,sans-serif;background:#0d1117;color:#e6edf3;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
-.card{text-align:center;padding:2rem 3rem;border:1px solid #30363d;border-radius:12px;background:#161b22}
-h1{margin:0 0 .5rem;font-size:1.4rem}p{margin:0;color:#8b949e}</style></head>
-<body><div class="card"><h1>__TITLE__</h1><p>__MSG__</p></div></body></html>`;
+.card{text-align:center;padding:2rem 3rem;border:1px solid #30363d;border-radius:12px;background:#161b22;max-width:30rem}
+h1{margin:0 0 .5rem;font-size:1.4rem}p{margin:.25rem 0;color:#8b949e}.hint{margin-top:1rem;font-size:.85rem;color:#6e7681}</style></head>
+<body><div class="card"><h1>__TITLE__</h1><p>__MSG__</p>__EXTRA__</div>__SCRIPT__</body></html>`;
+
+// Seconds before the success tab attempts to auto-close. `window.close()` only
+// succeeds on tabs the script itself opened; browsers may ignore it for
+// OS-launched OAuth tabs, so the page also shows a clear "you can close" hint.
+// ponytail: upgrade path — none needed; countdown is inline, no timer lib.
+const AUTO_CLOSE_SECONDS = 3;
 
 function renderHtml(ok: boolean, msg: string): string {
-  return SUCCESS_HTML
+  const extra = ok
+    ? `<p class="hint">This window will close in <span id="jeo-countdown">${AUTO_CLOSE_SECONDS}</span>s — you can also close it manually.</p>`
+    : "";
+  const script = ok
+    ? `<script>(function(){var n=${AUTO_CLOSE_SECONDS},el=document.getElementById("jeo-countdown");var t=setInterval(function(){n-=1;if(el)el.textContent=String(Math.max(n,0));if(n<=0){clearInterval(t);window.close();}},1000);})();</script>`
+    : "";
+  return PAGE_HTML
     .replace("__TITLE__", ok ? "Login complete \u2713" : "Login failed")
-    .replace("__MSG__", msg);
+    .replace("__MSG__", msg)
+    .replace("__EXTRA__", extra)
+    .replace("__SCRIPT__", script);
 }
 
 export abstract class OAuthCallbackFlow {
@@ -121,7 +135,7 @@ export abstract class OAuthCallbackFlow {
     else if (expectedState && state !== expectedState) message = "State mismatch — possible CSRF attack";
     else {
       ok = true;
-      message = "You can close this tab and return to the terminal.";
+      message = "Authentication succeeded. Return to the terminal — jeo is ready.";
     }
 
     const resolve = this.#resolve;

package/src/commands/launch/tmux.ts

@@ -2,6 +2,7 @@ import * as path from "node:path";
 import * as fs from "node:fs";
 import { type LaunchFlags } from "./flags";
 import { tmuxCopyCommand } from "../../tui/clipboard";
+import { jeoEnv } from "../../util/env";
 
 function hashString(input: string): string {
   let hash = 2166136261;
@@ -278,3 +279,137 @@ export function resolveWorktree(cwd: string, wt: string): string {
   }
   return abs;
 }
+/**
+ * Ownership / idle metadata for one tmux session, parsed from `tmux list-sessions`.
+ * Backs {@link reapStaleTmuxSessions}, the sweep that closes the orphaned-session
+ * leak (detached, long-idle `jeo launch` REPLs each pin tens of MB and pile up
+ * across days — the "jeo/bun 프로세스가 쌓여 메모리가 점점 커진다" report).
+ */
+export interface TmuxSessionInfo {
+  name: string;
+  /** A client is currently attached (someone is viewing it). */
+  attached: boolean;
+  /** Last-activity time, epoch SECONDS (tmux #{session_activity}). */
+  activitySec: number;
+  /** The @jeo-profile marker is set ⇒ jeo created/owns this session. */
+  jeoOwned: boolean;
+}
+
+/** Stable, tab-separated `tmux list-sessions -F` format the reaper parses. */
+export const TMUX_REAP_LIST_FORMAT =
+  "#{session_name}\t#{session_attached}\t#{session_activity}\t#{@jeo-profile}";
+
+/** Parse {@link TMUX_REAP_LIST_FORMAT} output into structured per-session info. */
+export function parseTmuxSessionList(raw: string): TmuxSessionInfo[] {
+  const out: TmuxSessionInfo[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    const [name, attached, activity, jeo] = line.split("\t");
+    if (!name) continue;
+    const activitySec = Number(activity);
+    out.push({
+      name,
+      attached: attached === "1",
+      activitySec: Number.isFinite(activitySec) ? activitySec : 0,
+      jeoOwned: jeo === "1",
+    });
+  }
+  return out;
+}
+
+/**
+ * Pure selector: which jeo-owned tmux sessions are safe to reap. A session is
+ * stale when jeo owns it (the @jeo-profile marker), NO client is attached, and it
+ * has been idle longer than `idleMs`. Sessions in `keep` (e.g. the one we are about
+ * to attach) are never selected. The interactive REPL persists its transcript to
+ * `.jeo/sessions/` and is resumable with `--resume`, so reaping an abandoned,
+ * unattached, idle REPL discards only its in-memory live view.
+ */
+export function selectReapableTmuxSessions(
+  sessions: TmuxSessionInfo[],
+  opts: { nowSec: number; idleMs: number; keep?: Iterable<string> },
+): string[] {
+  const keep = new Set(opts.keep ?? []);
+  const idleSec = opts.idleMs / 1000;
+  return sessions
+    .filter(s =>
+      s.jeoOwned &&
+      !s.attached &&
+      !keep.has(s.name) &&
+      opts.nowSec - s.activitySec >= idleSec,
+    )
+    .map(s => s.name);
+}
+
+/** Session reaping is on unless JEO_TMUX_REAP=0. */
+export function tmuxReapEnabled(env: Record<string, string | undefined> = process.env): boolean {
+  return jeoEnv("TMUX_REAP", env) !== "0";
+}
+
+/** Idle threshold before an unattached jeo session is reaped (default 6h). 0 reaps every idle one; invalid → default. */
+export function tmuxReapIdleMs(env: Record<string, string | undefined> = process.env): number {
+  const DEFAULT = 6 * 60 * 60 * 1000;
+  const raw = jeoEnv("TMUX_REAP_IDLE_MS", env);
+  if (raw == null) return DEFAULT;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT;
+}
+
+export interface TmuxReapDeps {
+  /** Raw `tmux list-sessions` output (TMUX_REAP_LIST_FORMAT), or null on failure. */
+  list?: () => string | null;
+  /** Kill one session by name. */
+  kill?: (name: string) => void;
+  /** Epoch-ms clock (injectable for tests). */
+  now?: () => number;
+  env?: Record<string, string | undefined>;
+}
+
+/**
+ * Best-effort sweep of orphaned jeo tmux sessions. Each detached, long-idle
+ * `jeo launch` REPL holds tens of MB forever, so over days dozens accumulate and
+ * aggregate RSS climbs monotonically. This reaps the jeo-owned sessions with no
+ * client attached that have outlived the idle TTL — never the freshly created
+ * session(s) in `keep`. Returns the reaped session names. Opt out: JEO_TMUX_REAP=0.
+ */
+export function reapStaleTmuxSessions(
+  tmuxBin: string,
+  keep: Iterable<string> = [],
+  deps: TmuxReapDeps = {},
+): string[] {
+  const env = deps.env ?? process.env;
+  if (!tmuxReapEnabled(env)) return [];
+  const now = deps.now ?? Date.now;
+  const list = deps.list ?? ((): string | null => {
+    try {
+      const res = Bun.spawnSync([tmuxBin, "list-sessions", "-F", TMUX_REAP_LIST_FORMAT], {
+        stdout: "pipe",
+        stderr: "ignore",
+      });
+      return res.exitCode === 0 ? res.stdout.toString() : null;
+    } catch {
+      return null;
+    }
+  });
+  const raw = list();
+  if (!raw) return [];
+  const reapable = selectReapableTmuxSessions(parseTmuxSessionList(raw), {
+    nowSec: Math.floor(now() / 1000),
+    idleMs: tmuxReapIdleMs(env),
+    keep,
+  });
+  if (reapable.length === 0) return [];
+  const kill = deps.kill ?? ((name: string): void => {
+    try {
+      Bun.spawnSync([tmuxBin, "kill-session", "-t", `=${name}`], { stdout: "ignore", stderr: "ignore" });
+    } catch {
+      /* best-effort: the session may have died on its own between list and kill */
+    }
+  });
+  const reaped: string[] = [];
+  for (const name of reapable) {
+    kill(name);
+    reaped.push(name);
+  }
+  return reaped;
+}

package/src/commands/launch.ts

@@ -123,6 +123,7 @@ import {
   currentTmuxClipboardCommands,
   resolveWorktree,
   shellQuote,
+  reapStaleTmuxSessions,
   type TmuxCreateResult,
   type TmuxProfileCommand,
 } from "./launch/tmux";
@@ -210,6 +211,7 @@ export {
   currentTmuxClipboardCommands,
   resolveWorktree,
   shellQuote,
+  reapStaleTmuxSessions,
   type TmuxCreateResult,
   type TmuxProfileCommand,
   type InFlightAbortHarness,
@@ -402,6 +404,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         for (const profileCmd of tmuxProfileCommands(sessionName, process.env, { branch: branch || undefined, project: cwd })) {
           try { Bun.spawnSync([tmuxBin, ...profileCmd.args]); } catch { /* best-effort */ }
         }
+        // Reap orphaned jeo sessions: each detached, long-idle `jeo launch` REPL
+        // pins tens of MB forever, so over days they pile up and aggregate RSS
+        // climbs (the "jeo/bun 프로세스가 쌓여 메모리가 점점 커진다" report). Sweep the
+        // jeo-owned, unattached, long-idle ones — never the one just created.
+        // Best-effort; opt out with JEO_TMUX_REAP=0.
+        try {
+          const reaped = reapStaleTmuxSessions(tmuxBin, [sessionName]);
+          if (reaped.length > 0) {
+            console.log(
+              `Reaped ${reaped.length} idle jeo tmux session${reaped.length === 1 ? "" : "s"}: ${reaped.join(", ")}`,
+            );
+          }
+        } catch { /* best-effort */ }
         console.log(
           sessionName === sessionBase
             ? `Starting new tmux session: ${sessionName}`