wtt-connect 0.2.26 → 0.2.28

package/README.md

@@ -25,7 +25,7 @@ Implemented production-oriented surfaces:
   - `none`
   - `macos-say` using the macOS `say` command, emitted as WAV when upload is enabled
 - HTTP task status update path
-- Permission broker for agent modes; `full-auto` is the default no-approval mode for Codex and Claude Code
+- Permission broker for agent modes; Codex, Claude Code, and Gemini default to `yolo` no-approval/full-access mode when bound through `wtt-connect up`
 - Optional WTT media artifact upload path (`/media/sign` → direct upload → `/media/commit`)
 - Agent-generated file artifacts for WTT feed chat (`.docx`, `.pptx`, `.xlsx`, `.pdf`, `.csv`, `.zip`) using explicit final-response markers that are converted into WTT file cards
 - Attachment staging for WTT message media/files; image attachments are passed to adapters that support image inputs, such as Codex with `--image`; Claude Code stays on the Claude Code adapter and returns its own result if the selected model cannot reason over images
@@ -45,6 +45,7 @@ Install once, then bind each WTT agent identity with one command:
 npm install -g wtt-connect
 wtt-connect up codex agent-001 'wtt-tok-001'
 wtt-connect up claude-code agent-002 'wtt-tok-002'
+wtt-connect up gemini agent-003 'wtt-tok-003'
 ```
 
 `up` writes a profile, installs a background service, enables it for the current user, starts it immediately, and prints status. On Linux it installs a `systemd --user` service; on macOS it installs a LaunchAgent. The npm install step installs package dependencies such as `node-pty`; users should not need to run `npm install` inside a cloned source tree.
@@ -89,7 +90,7 @@ Important settings:
 - `WTT_CONNECT_ADAPTERS=codex,claude-code,cursor,gemini,qoder,opencode,iflow,kimi,pi,acp,devin`
 - `WTT_CONNECT_WORKDIR`
 - `WTT_CONNECT_MODE=full-auto|auto-edit|yolo|suggest`
-- `full-auto` is the default no-approval mode: Codex runs with `--dangerously-bypass-approvals-and-sandbox`; Claude Code runs with `--dangerously-skip-permissions --permission-mode bypassPermissions`
+- Codex, Claude Code, and Gemini default to `yolo` no-approval/full-access mode when no explicit mode is set. Codex runs with `--dangerously-bypass-approvals-and-sandbox`; Claude Code runs with `--dangerously-skip-permissions --permission-mode bypassPermissions`; Gemini runs with `-y`.
 - `WTT_CONNECT_AGENT_ALIASES=alias1,alias2` for extra @mention names in discussion/collaborative topics; `WTT_AGENT_ID` always works
 - `WTT_CONNECT_ALLOW_YOLO=1` only when intentionally using `yolo`
 - `WTT_CONNECT_STATE_DIR` / `WTT_CONNECT_STORE_FILE` for durable sessions
@@ -119,6 +120,7 @@ Session continuity:
 - `wtt-connect` uses the WTT topic/task id plus adapter and model as the local session key, for example `wtt:topic:<topic_id>:codex:gpt-5.5:high`.
 - Codex stores `codexThreadId` and resumes with `codex exec resume`.
 - Claude Code stores `claudeSessionId` and resumes the same topic with `claude --resume <session_id> -p ...`.
+- Gemini stores `geminiSessionId` and resumes with `gemini --resume <session_id> --output-format stream-json`.
 - Keep `WTT_CONNECT_STATE_DIR`, `WTT_CONNECT_STORE_FILE`, and `WTT_CONNECT_WORKDIR` stable per claimed agent. If they are changed or deleted, the adapter cannot resume previous local sessions.
 
 A JSON config may also be supplied:
@@ -180,6 +182,22 @@ Examples:
 wtt-connect up codex agent-alice 'wtt-tok-alice'
 wtt-connect up codex agent-bob 'wtt-tok-bob'
 wtt-connect up claude-code agent-claude 'wtt-tok-claude'
+wtt-connect up gemini agent-gemini 'wtt-tok-gemini'
+```
+
+Gemini CLI uses Google OAuth by default. Install/authenticate Gemini on the agent host first, then bind it to WTT:
+
+```bash
+npm install -g @google/gemini-cli
+gemini
+npm install -g wtt-connect
+wtt-connect up gemini agent-gemini 'wtt-tok-gemini'
+```
+
+If the `gemini` binary is not on `PATH`, set `WTT_GEMINI_BIN` in the profile or shell before starting:
+
+```bash
+WTT_GEMINI_BIN="$HOME/.local/bin/gemini" wtt-connect up gemini agent-gemini 'wtt-tok-gemini'
 ```
 
 Each call creates an independent profile and service:
@@ -196,7 +214,7 @@ On macOS the same profile and state paths are used, while the service file is:
 ~/Library/LaunchAgents/com.wtt.connect.agent-alice-codex.plist
 ```
 
-A profile contains exactly one WTT identity: `WTT_AGENT_ID`, `WTT_TOKEN`, adapter, workdir, permission mode, and state directory. Multiple profiles may point at the same local `codex` or `claude` CLI binary; they must not share `WTT_AGENT_ID`, `WTT_TOKEN`, or `WTT_CONNECT_STATE_DIR`.
+A profile contains exactly one WTT identity: `WTT_AGENT_ID`, `WTT_TOKEN`, adapter, workdir, permission mode, and state directory. Multiple profiles may point at the same local `codex`, `claude`, or `gemini` CLI binary; they must not share `WTT_AGENT_ID`, `WTT_TOKEN`, or `WTT_CONNECT_STATE_DIR`.
 
 Workdir rules:
 
@@ -208,13 +226,13 @@ Useful flags:
 
 ```bash
 wtt-connect up codex agent-alice 'wtt-tok-alice' \
-  --mode yolo \
-  --allow-yolo \
   --workdir /data/workspaces/alice \
   --base-url https://www.waxbyte.com \
   --enable-linger
 ```
 
+`codex`, `claude-code`, and `gemini` already default to `--mode yolo` with `WTT_CONNECT_ALLOW_YOLO=1`. Pass `--mode suggest` or `--mode auto-edit` only when you intentionally want stricter behavior.
+
 `--enable-linger` asks systemd to start the Linux user service at boot before an interactive login. Without it, the service starts when the user session starts. On macOS LaunchAgents start at user login; `--enable-linger` is ignored with a warning.
 
 Start an already-created profile in the foreground:
@@ -261,11 +279,22 @@ WTT_CONNECT_ADAPTERS=claude-code
 WTT_CONNECT_STATE_DIR=.wtt-connect-claude
 ```
 
+```dotenv
+# .env.gemini
+WTT_AGENT_ID=agent-gemini
+WTT_TOKEN=***
+WTT_CONNECT_ADAPTER=gemini
+WTT_CONNECT_ADAPTERS=gemini
+WTT_CONNECT_STATE_DIR=.wtt-connect-gemini
+WTT_GEMINI_BIN=gemini
+```
+
 Start them separately:
 
 ```bash
 ./start.sh --env-file .env.codex
 ./start.sh --env-file .env.claude
+./start.sh --env-file .env.gemini
 ```
 
 Install them as separate macOS LaunchAgents:
@@ -273,6 +302,7 @@ Install them as separate macOS LaunchAgents:
 ```bash
 ./scripts/install-launchd.sh --name codex --env-file .env.codex
 ./scripts/install-launchd.sh --name claude --env-file .env.claude
+./scripts/install-launchd.sh --name gemini --env-file .env.gemini
 ```
 
 Install them as separate Linux `systemd --user` services from a source checkout if you are not using npm:
@@ -280,6 +310,7 @@ Install them as separate Linux `systemd --user` services from a source checkout
 ```bash
 ./scripts/install-agent.sh codex agent-codex '***'
 ./scripts/install-agent.sh claude-code agent-claude '***'
+./scripts/install-agent.sh gemini agent-gemini '***'
 ```
 
 The npm equivalent is preferred for end users:
@@ -287,6 +318,7 @@ The npm equivalent is preferred for end users:
 ```bash
 wtt-connect up codex agent-codex '***'
 wtt-connect up claude-code agent-claude '***'
+wtt-connect up gemini agent-gemini '***'
 ```
 
 Use named options when you need a custom service name, a stricter permission mode, or boot-before-login behavior:
@@ -306,12 +338,19 @@ Use named options when you need a custom service name, a stricter permission mod
   --agent-id agent-claude \
   --token '***' \
   --adapter claude-code \
-  --mode full-auto \
+  --publish-progress \
+  --enable-linger
+
+./scripts/install-systemd-user.sh \
+  --name alice-gemini \
+  --agent-id agent-gemini \
+  --token '***' \
+  --adapter gemini \
   --publish-progress \
   --enable-linger
 ```
 
-Each invocation writes a separate `.env.<name>`, `.wtt-connect-<name>` state directory, and `wtt-connect-<name>.service`. Multiple WTT agent identities may share the same local `codex` or `claude` CLI binary; only the WTT identity and state directory need to be unique.
+Each invocation writes a separate `.env.<name>`, `.wtt-connect-<name>` state directory, and `wtt-connect-<name>.service`. Multiple WTT agent identities may share the same local `codex`, `claude`, or `gemini` CLI binary; only the WTT identity and state directory need to be unique.
 
 Uninstall one identity with:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/scripts/install-systemd-user.sh

@@ -28,8 +28,8 @@ Options:
   --workdir <dir>         Agent working directory (default: wtt-connect root)
   --env-file <file>       Env file to write (default: .env.<name>)
   --state-dir <dir>       State directory (default: .wtt-connect-<name>)
-  --mode <mode>           full-auto, auto-edit, suggest, yolo (default: full-auto)
-  --allow-yolo            Required when --mode yolo is used
+  --mode <mode>           full-auto, auto-edit, suggest, yolo (default: yolo for codex/claude-code/gemini)
+  --allow-yolo            Allow yolo mode for adapters that do not default to full access
   --publish-progress      Publish agent progress/status messages
   --timeout <seconds>     Per-run timeout (default: 3600)
   --node-bin <path>       node binary (default: command -v node)
@@ -49,7 +49,7 @@ BASE_URL="https://www.waxbyte.com"
 WORKDIR="$ROOT"
 ENV_FILE=""
 STATE_DIR=""
-MODE="${WTT_CONNECT_MODE:-full-auto}"
+MODE="${WTT_CONNECT_MODE:-}"
 ALLOW_YOLO=0
 PUBLISH_PROGRESS=0
 TIMEOUT_SECONDS=3600
@@ -98,6 +98,21 @@ if [[ "${#POSITIONAL[@]}" -gt 0 ]]; then
 fi
 
 ADAPTER="${ADAPTER:-codex}"
+case "$ADAPTER" in
+  claude) ADAPTER="claude-code" ;;
+  cc-connect) ADAPTER="codex" ;;
+esac
+if [[ -z "$MODE" ]]; then
+  case "$ADAPTER" in
+    codex|claude-code|gemini)
+      MODE="yolo"
+      ALLOW_YOLO=1
+      ;;
+    *)
+      MODE="full-auto"
+      ;;
+  esac
+fi
 if [[ -z "$NAME" && -n "$AGENT_ID" ]]; then
   NAME="$AGENT_ID-$ADAPTER"
 fi

package/src/adapters/generic-cli.js

@@ -144,6 +144,12 @@ export class GenericCliAdapter {
       if (context.onProgress) context.onProgress(event).catch(() => {});
     }, this.config.taskTimeoutSeconds * 1000);
     if (result.sessionId) this.store?.patchSession(sessionKey, { [storedKey]: result.sessionId, adapter: this.name });
+    const runtimePatch = {
+      ...(result.model ? { current_model: result.model, model: result.model, model_source: `${this.name}_runtime` } : {}),
+      ...(result.reasoningEffort ? { reasoning_effort: result.reasoningEffort } : {}),
+      ...(result.thinkingMode ? { thinking_mode: result.thinkingMode } : {}),
+    };
+    if (Object.keys(runtimePatch).length) this.store?.patchRuntime(runtimePatch);
     return result.text.trim();
   }
 }
@@ -166,6 +172,9 @@ function runCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
     let stderr = '';
     let plainStdout = '';
     let sessionId = '';
+    let model = '';
+    let reasoningEffort = '';
+    let thinkingMode = '';
     const texts = [];
     const timer = setTimeout(() => {
       child.kill('SIGTERM');
@@ -183,6 +192,9 @@ function runCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
       }
       const eventSessionId = extractSessionId(event);
       if (eventSessionId) sessionId = eventSessionId;
+      model = extractModel(event) || model;
+      reasoningEffort = extractReasoningEffort(event) || reasoningEffort;
+      thinkingMode = extractThinkingMode(event) || thinkingMode;
       const text = extractText(event);
       if (text) texts.push({ text, delta: event.delta === true });
       onEvent?.(event);
@@ -190,12 +202,55 @@ function runCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
     child.on('close', (code) => {
       clearTimeout(timer);
       if (code !== 0) reject(new Error(`${bin} exited ${code}: ${stderr.trim()}`));
-      else resolve({ text: collapseText(texts, plainStdout), sessionId });
+      else resolve({ text: collapseText(texts, plainStdout), sessionId, model, reasoningEffort, thinkingMode });
     });
     if (stdinText != null) child.stdin.end(stdinText);
   });
 }
 
+function extractModel(event) {
+  if (!event || typeof event !== 'object') return '';
+  for (const key of ['model', 'model_id', 'modelId', 'current_model']) {
+    const value = event[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  const statsModels = event.stats?.models;
+  if (statsModels && typeof statsModels === 'object' && !Array.isArray(statsModels)) {
+    const entries = Object.entries(statsModels).filter(([name]) => String(name || '').trim());
+    if (entries.length) {
+      entries.sort((a, b) => modelTokenTotal(b[1]) - modelTokenTotal(a[1]));
+      return String(entries[0][0]).trim();
+    }
+  }
+  return '';
+}
+
+function modelTokenTotal(value) {
+  if (!value || typeof value !== 'object') return 0;
+  return Number(value.total_tokens || value.totalTokens || value.output_tokens || value.outputTokens || 0) || 0;
+}
+
+function extractReasoningEffort(event) {
+  const raw = event?.reasoning_effort || event?.reasoningEffort || event?.thinking_effort || event?.thinkingEffort;
+  return normalizeReasoning(raw);
+}
+
+function extractThinkingMode(event) {
+  const raw = event?.thinking_mode || event?.thinkingMode || event?.thinking || event?.displayThinking;
+  if (typeof raw === 'boolean') return raw ? 'high' : 'off';
+  return typeof raw === 'string' ? raw.trim() : '';
+}
+
+function normalizeReasoning(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (['off', 'none', 'disabled', 'false', '0'].includes(raw)) return 'off';
+  if (['low', 'minimal'].includes(raw)) return 'low';
+  if (['medium', 'normal', 'auto'].includes(raw)) return 'medium';
+  if (['high', 'full', 'max', 'maximum', 'xhigh'].includes(raw)) return 'high';
+  return raw;
+}
+
 function collapseText(texts, plainStdout) {
   const filtered = texts
     .map((entry) => ({ text: String(entry?.text || ''), delta: entry?.delta === true }))

package/src/config.js

@@ -3,6 +3,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { parseBool, parseIntEnv } from './env.js';
 
+const FULL_ACCESS_DEFAULT_ADAPTERS = new Set(['codex', 'claude-code', 'gemini']);
+
 function wsUrl(base, agentId) {
   let b = String(base || '').replace(/\/$/, '');
   if (b.endsWith('/api/v1')) b = b.slice(0, -7);
@@ -27,6 +29,8 @@ export function loadConfig(argv = {}) {
   const token = process.env.WTT_TOKEN || process.env.WTT_AGENT_TOKEN || fileConfig.token || '';
   const adapter = process.env.WTT_CONNECT_ADAPTER || fileConfig.adapter || 'codex';
   const adapters = String(process.env.WTT_CONNECT_ADAPTERS || fileConfig.adapters || adapter).split(',').map((x) => x.trim()).filter(Boolean);
+  const defaultMode = defaultModeForAdapters(adapter, adapters);
+  const mode = process.env.WTT_CONNECT_MODE || fileConfig.mode || defaultMode;
   const explicitWorkDir = process.env.WTT_CONNECT_WORKDIR || fileConfig.workDir || '';
   const workDir = resolveAgentWorkDir(explicitWorkDir, agentId);
   const stateDir = process.env.WTT_CONNECT_STATE_DIR || fileConfig.stateDir || path.join(workDir, '.wtt-connect');
@@ -52,8 +56,8 @@ export function loadConfig(argv = {}) {
     },
     workDir,
     model: process.env.WTT_CONNECT_MODEL || fileConfig.model || '',
-    mode: process.env.WTT_CONNECT_MODE || fileConfig.mode || 'full-auto',
-    allowYolo: parseBool(process.env.WTT_CONNECT_ALLOW_YOLO, fileConfig.allowYolo ?? false),
+    mode,
+    allowYolo: parseBool(process.env.WTT_CONNECT_ALLOW_YOLO, fileConfig.allowYolo ?? mode === 'yolo'),
     reasoningEffort: process.env.WTT_CONNECT_REASONING_EFFORT || fileConfig.reasoningEffort || 'low',
     codexBin: process.env.WTT_CODEX_BIN || fileConfig.codexBin || 'codex',
     claudeBin: process.env.WTT_CLAUDE_BIN || fileConfig.claudeBin || 'claude',
@@ -112,6 +116,20 @@ export function loadConfig(argv = {}) {
   };
 }
 
+function defaultModeForAdapters(adapter, adapters) {
+  const names = [adapter, ...(Array.isArray(adapters) ? adapters : [])]
+    .map(normalizeAdapter)
+    .filter(Boolean);
+  return names.some((name) => FULL_ACCESS_DEFAULT_ADAPTERS.has(name)) ? 'yolo' : 'full-auto';
+}
+
+function normalizeAdapter(name) {
+  const normalized = String(name || '').trim().toLowerCase();
+  if (normalized === 'claude') return 'claude-code';
+  if (normalized === 'cc-connect') return 'codex';
+  return normalized;
+}
+
 export function resolveAgentWorkDir(explicitWorkDir, agentId) {
   if (explicitWorkDir) return path.resolve(String(explicitWorkDir));
   return path.join(os.homedir(), '.wtt-connect', safeAgentPathSegment(agentId));

package/src/runner.js

@@ -388,6 +388,7 @@ export class Runner {
       ...(reasoning ? { reasoning_effort: reasoning } : {}),
       status,
     });
+    this.wtt.sendHeartbeat().catch(() => {});
   }
 
   async transcribeAttachments(files) {

package/src/runtime-info.js

@@ -8,6 +8,8 @@ export function buildRuntimeInfo(config, runtimeState = {}) {
   const git = gitInfo(workdir);
   const adapter = String(runtimeState.adapter || config.adapter || '').trim();
   const model = runtimeModel(config, adapter, runtimeState);
+  const reasoning = runtimeReasoningEffort(config, adapter, runtimeState);
+  const thinkingMode = runtimeThinkingMode(config, adapter, runtimeState);
   return {
     kind: 'wtt-connect',
     agent_id: config.agentId,
@@ -16,7 +18,8 @@ export function buildRuntimeInfo(config, runtimeState = {}) {
     ...(model ? { model, current_model: model } : {}),
     ...(runtimeState.model_source ? { model_source: String(runtimeState.model_source) } : {}),
     ...(runtimeState.status ? { runtime_status: String(runtimeState.status) } : {}),
-    ...(runtimeState.reasoning_effort || config.reasoningEffort ? { reasoning_effort: String(runtimeState.reasoning_effort || config.reasoningEffort) } : {}),
+    ...(reasoning ? { reasoning_effort: reasoning } : {}),
+    ...(thinkingMode ? { thinking_mode: thinkingMode } : {}),
     workdir,
     workdir_name: path.basename(workdir || ''),
     cwd: safeRealpath(process.cwd()),
@@ -45,9 +48,37 @@ function runtimeModel(config, adapter, runtimeState = {}) {
   if (normalizedAdapter === 'claude-code' || normalizedAdapter === 'claude' || normalizedAdapter === 'claude_code') {
     return String(process.env.ANTHROPIC_MODEL || readClaudeConfigModel() || '').trim();
   }
+  if (normalizedAdapter === 'gemini') {
+    return String(process.env.GEMINI_MODEL || process.env.GEMINI_CLI_MODEL || process.env.GOOGLE_GEMINI_MODEL || readGeminiConfigModel() || '').trim();
+  }
   return String(process.env.WTT_CONNECT_MODEL || '').trim();
 }
 
+function runtimeReasoningEffort(config, adapter, runtimeState = {}) {
+  const fromRun = normalizeReasoning(runtimeState.reasoning_effort || runtimeState.reasoningEffort);
+  if (fromRun) return fromRun;
+
+  const explicit = normalizeReasoning(config.reasoningEffort || config.reasoning_effort);
+  if (explicit) return explicit;
+
+  const normalizedAdapter = String(adapter || config.adapter || '').trim().toLowerCase();
+  if (normalizedAdapter === 'codex') return normalizeReasoning(process.env.OPENAI_REASONING_EFFORT || process.env.CODEX_REASONING_EFFORT || readCodexReasoningEffort());
+  if (normalizedAdapter === 'gemini') return normalizeReasoning(process.env.GEMINI_THINKING || process.env.GEMINI_THINKING_MODE || readGeminiThinkingMode());
+  if (normalizedAdapter === 'claude-code' || normalizedAdapter === 'claude' || normalizedAdapter === 'claude_code') {
+    return normalizeReasoning(process.env.CLAUDE_THINKING || process.env.ANTHROPIC_THINKING || readClaudeThinkingMode());
+  }
+  return normalizeReasoning(process.env.WTT_CONNECT_REASONING_EFFORT);
+}
+
+function runtimeThinkingMode(config, adapter, runtimeState = {}) {
+  const value = String(runtimeState.thinking_mode || runtimeState.thinkingMode || '').trim();
+  if (value) return value;
+  const normalizedAdapter = String(adapter || config.adapter || '').trim().toLowerCase();
+  if (normalizedAdapter === 'gemini') return readGeminiThinkingMode();
+  if (normalizedAdapter === 'claude-code' || normalizedAdapter === 'claude' || normalizedAdapter === 'claude_code') return readClaudeThinkingMode();
+  return '';
+}
+
 function readCodexConfigModel() {
   const home = os.homedir();
   const candidates = [
@@ -61,6 +92,19 @@ function readCodexConfigModel() {
   return '';
 }
 
+function readCodexReasoningEffort() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.codex', 'config.toml'),
+    path.join(home, '.config', 'codex', 'config.toml'),
+  ];
+  for (const file of candidates) {
+    const effort = readTomlStringKey(file, 'model_reasoning_effort') || readTomlStringKey(file, 'reasoning_effort');
+    if (effort) return effort;
+  }
+  return '';
+}
+
 function readClaudeConfigModel() {
   const home = os.homedir();
   const candidates = [
@@ -75,6 +119,50 @@ function readClaudeConfigModel() {
   return '';
 }
 
+function readClaudeThinkingMode() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.claude.json'),
+    path.join(home, '.claude', 'settings.json'),
+    path.join(home, '.config', 'claude', 'settings.json'),
+  ];
+  for (const file of candidates) {
+    const mode = readJsonThinkingKey(file);
+    if (mode) return mode;
+  }
+  return '';
+}
+
+function readGeminiConfigModel() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.gemini', 'settings.json'),
+    path.join(home, '.gemini', 'config.json'),
+    path.join(home, '.config', 'gemini', 'settings.json'),
+    path.join(home, '.config', 'gemini', 'config.json'),
+  ];
+  for (const file of candidates) {
+    const model = readJsonModelKey(file);
+    if (model) return model;
+  }
+  return '';
+}
+
+function readGeminiThinkingMode() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.gemini', 'settings.json'),
+    path.join(home, '.gemini', 'config.json'),
+    path.join(home, '.config', 'gemini', 'settings.json'),
+    path.join(home, '.config', 'gemini', 'config.json'),
+  ];
+  for (const file of candidates) {
+    const mode = readJsonThinkingKey(file);
+    if (mode) return mode;
+  }
+  return '';
+}
+
 function readJsonModelKey(file) {
   try {
     if (!fs.existsSync(file)) return '';
@@ -85,8 +173,23 @@ function readJsonModelKey(file) {
   }
 }
 
+function readJsonThinkingKey(file) {
+  try {
+    if (!fs.existsSync(file)) return '';
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return findThinkingValue(parsed);
+  } catch {
+    return '';
+  }
+}
+
 function findModelValue(value, depth = 0) {
   if (!value || typeof value !== 'object' || depth > 4) return '';
+  const modelObj = value.model;
+  if (modelObj && typeof modelObj === 'object') {
+    const name = modelObj.name;
+    if (typeof name === 'string' && name.trim()) return name.trim();
+  }
   for (const key of ['model', 'model_id', 'modelId', 'defaultModel', 'default_model']) {
     const raw = value[key];
     if (typeof raw === 'string' && raw.trim()) return raw.trim();
@@ -98,6 +201,37 @@ function findModelValue(value, depth = 0) {
   return '';
 }
 
+function findThinkingValue(value, depth = 0) {
+  if (!value || typeof value !== 'object' || depth > 6) return '';
+  for (const key of ['thinking_mode', 'thinkingMode', 'thinking', 'displayThinking', 'reasoning_effort', 'reasoningEffort', 'thinkingLevel']) {
+    const raw = value[key];
+    if (typeof raw === 'string' && raw.trim()) return raw.trim();
+    if (typeof raw === 'boolean') return raw ? 'high' : 'off';
+  }
+  const budget = value.thinkingBudget ?? value.thinking_budget;
+  if (typeof budget === 'number') {
+    if (budget <= 0) return 'off';
+    if (budget >= 8192) return 'high';
+    if (budget >= 2048) return 'medium';
+    return 'low';
+  }
+  for (const child of Object.values(value)) {
+    const found = findThinkingValue(child, depth + 1);
+    if (found) return found;
+  }
+  return '';
+}
+
+function normalizeReasoning(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (['off', 'none', 'disabled', 'false', '0'].includes(raw)) return 'off';
+  if (['low', 'minimal'].includes(raw)) return 'low';
+  if (['medium', 'normal', 'auto'].includes(raw)) return 'medium';
+  if (['high', 'full', 'max', 'maximum', 'xhigh'].includes(raw)) return 'high';
+  return raw;
+}
+
 function readTomlStringKey(file, key) {
   try {
     if (!fs.existsSync(file)) return '';

package/src/service-manager.js

@@ -8,6 +8,7 @@ import { resolveAgentWorkDir } from './config.js';
 
 const DEFAULT_BASE_URL = 'https://www.waxbyte.com';
 const DEFAULT_MODE = 'full-auto';
+const FULL_ACCESS_DEFAULT_ADAPTERS = new Set(['codex', 'claude-code', 'gemini']);
 const VALID_MODES = new Set(['suggest', 'auto-edit', 'full-auto', 'yolo']);
 
 export function resolveProfileEnvFile(profile) {
@@ -23,9 +24,11 @@ export async function up(argv) {
   }
 
   const profile = sanitizeProfile(argv.profile || argv.name || `${agentId}-${adapter}`);
-  const mode = argv.mode || process.env.WTT_CONNECT_MODE || DEFAULT_MODE;
+  const defaultMode = FULL_ACCESS_DEFAULT_ADAPTERS.has(adapter) ? 'yolo' : DEFAULT_MODE;
+  const mode = argv.mode || process.env.WTT_CONNECT_MODE || defaultMode;
   if (!VALID_MODES.has(mode)) throw new Error(`invalid --mode: ${mode}`);
-  if (mode === 'yolo' && !argv.allowYolo && !argv.yes) {
+  const allowYolo = mode === 'yolo' && FULL_ACCESS_DEFAULT_ADAPTERS.has(adapter) ? true : Boolean(argv.allowYolo || argv.yes);
+  if (mode === 'yolo' && !allowYolo) {
     throw new Error('--mode yolo requires --allow-yolo or --yes');
   }
 
@@ -53,7 +56,7 @@ export async function up(argv) {
     WTT_CONNECT_ADAPTERS: adapter,
     WTT_CONNECT_WORKDIR: workDir,
     WTT_CONNECT_MODE: mode,
-    WTT_CONNECT_ALLOW_YOLO: mode === 'yolo' || argv.allowYolo || argv.yes ? '1' : '',
+    WTT_CONNECT_ALLOW_YOLO: mode === 'yolo' || allowYolo ? '1' : '',
     WTT_CONNECT_ENABLE_CHAT: '1',
     WTT_CONNECT_PUBLISH_PROGRESS: argv.publishProgress ? '1' : '0',
     WTT_CONNECT_TASK_TIMEOUT_SECONDS: String(argv.timeoutSeconds || (argv.timeout ? Math.round(argv.timeout / 1000) : 3600)),