agy-mcp-bridge 0.1.8 → 0.1.9

package/README.md

@@ -226,7 +226,7 @@ Luồng sử dụng trong Codex hoặc Claude Code:
 
 1. Đọc code và Git status trước task; chia task nhỏ, rõ file được sửa và tiêu chí nghiệm thu.
 2. Gọi `antigravity_delegate` với arguments mẫu ở dưới.
-3. Lưu `task_id`; gọi `antigravity_task_wait` (tối đa 25 giây mỗi lần, trả sớm khi task xong) hoặc `antigravity_task_status`, rồi lấy `antigravity_task_output`.
+3. Lưu `task_id`; gọi `antigravity_task_wait` (mỗi lần chờ tối đa `max_wait_seconds`, mặc định 55 giây, trả sớm khi task xong) hoặc `antigravity_task_status`, rồi lấy `antigravity_task_output`.
 4. Nếu client bị đóng, bật lại client, gọi environment để xem `recent_tasks`, rồi query task ID cũ. Không giao trùng task khi chưa kiểm tra trạng thái.
 5. Tech Lead review diff thực tế, gồm file untracked, chạy test và đánh giá từng tiêu chí. Nếu chưa đạt, giao task sửa tiếp.
 
@@ -244,7 +244,7 @@ Luồng sử dụng trong Codex hoặc Claude Code:
 | `antigravity_environment` | CLI/version/allowlist/giới hạn và recent_tasks để tìm lại task ID |
 | `antigravity_delegate` | Nhận task, workspace, acceptance_criteria, context?, timeout_seconds?; trả `running` (hoặc `queued` nếu bridge đang bận và hàng đợi còn chỗ) cùng task_id |
 | `antigravity_task_status` | Trạng thái/process/thời gian/lỗi/denied_actions/số byte theo task_id, không kèm log (rẻ để poll) |
-| `antigravity_task_wait` | Chờ tối đa `wait_seconds` (1–25, mặc định 20) tới khi task kết thúc, trả cùng nội dung như status; còn chạy thì gọi lại |
+| `antigravity_task_wait` | Chờ tối đa `wait_seconds` (1 đến `max_wait_seconds`, mặc định là mức tối đa, 55 giây) tới khi task kết thúc, trả cùng nội dung như status; còn chạy thì gọi lại |
 | `antigravity_task_output` | Phản hồi cuối, stdout/stderr, lỗi, denied_actions, truncation theo task_id |
 | `antigravity_cancel_task` | Hủy cây tiến trình thuộc task; không rollback thay đổi file |
 
@@ -376,6 +376,10 @@ Lưu ý bảo mật: nội dung yêu cầu và phản hồi được hiển th
 
 **Ghi chú phát hành:** mỗi lần workflow phát hành, nó tạo một GitHub Release cho tag `vX.Y.Z` với ghi chú tự sinh gồm các pull request đã merge kể từ tag trước (tên PR là nội dung ghi chú, nên hãy đặt tên PR nêu rõ thay đổi). Xem tại trang Releases của repo. Các tag cũ chưa có release cũng được tạo bù, theo thứ tự từ cũ đến mới.
 
+**Mức suy luận (effort):** mục Cài đặt → Mức suy luận chọn `--effort` truyền cho Antigravity: thấp (nhanh nhất), vừa, cao, rất cao, tối đa, hoặc mặc định (không truyền cờ). Mức thấp giúp task nhanh hơn nhưng suy luận ít hơn. Có hiệu lực ngay cho task mới, mỗi task ghi lại mức đã dùng, lưu ở `.bridge-state/effort.json`. Chưa kiểm chứng với `agy` thật ở chế độ `--print`. Kết hợp chọn model nhỏ hơn (ví dụ `gemini-3.8-flash-low`) để tăng tốc.
+
+**Giảm số lần Codex/Claude phải hỏi lại (tiết kiệm token):** mỗi lần gọi `antigravity_task_wait` tốn token, nên nên chờ lâu trong một lần gọi thay vì nhiều lần ngắn. Server không thể tự "đánh thức" Codex/Claude khi có kết quả: thông báo MCP từ server không khiến mô hình chạy, mô hình chỉ hành động khi được nhắn hoặc khi nó gọi tool. Vì vậy bridge cho chờ dài: mặc định một lần chờ tối đa 55 giây (nhỏ hơn thời hạn tool 60 giây mặc định của Codex). Muốn chờ lâu hơn nữa, nâng đồng thời hai giá trị: `max_wait_seconds` trong file cấu hình của bridge (5 đến 3600) và thời hạn tool của client (Codex: `tool_timeout_sec` trong `config.toml`; Claude Code: biến môi trường `MCP_TOOL_TIMEOUT` tính bằng mili giây, theo tài liệu của Claude Code, chưa kiểm chứng ở đây). Ví dụ `max_wait_seconds: 540` cùng `tool_timeout_sec = 600` thì một lần gọi chờ tới 9 phút. Nếu thời hạn tool của client ngắn hơn `max_wait_seconds`, lần chờ dài sẽ bị client cắt và báo lỗi timeout. File skill dặn Codex/Claude gọi `wait` không kèm `wait_seconds` và không báo tiến độ giữa các lần chờ.
+
 **Quyền của Antigravity:** mục Cài đặt → Quyền của Antigravity chọn Antigravity được tự làm đến đâu khi chạy task. Ở chế độ không tương tác, Antigravity tự từ chối việc cần phê duyệt (thấy ở `denied_actions`), nên task sửa file hay chạy lệnh có thể không làm được nếu cài đặt Antigravity chưa cấp quyền. Năm mức, từ thấp đến cao:
 
 | Mức | Cờ truyền cho `agy` | Ý nghĩa |

package/dist/src/config.js

@@ -11,7 +11,9 @@ const schema = z.object({
     max_retained_tasks: z.number().int().min(1).max(200).default(50),
     max_queued_tasks: z.number().int().min(0).max(20).default(3),
     extra_env_passthrough: z.array(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/)).max(100).default([]),
-    prompt_transport: z.enum(['stdin', 'argv']).default('argv')
+    prompt_transport: z.enum(['stdin', 'argv']).default('argv'),
+    /** Longest single antigravity_task_wait call (default 55). Keep it below the MCP client's tool timeout. */
+    max_wait_seconds: z.number().int().min(5).max(3600).optional()
 }).strict();
 const DEFAULT_LIMITS = { max_timeout_seconds: 900, default_timeout_seconds: 300, max_output_bytes: 262144, max_retained_tasks: 50, max_queued_tasks: 3, extra_env_passthrough: [], prompt_transport: 'argv' };
 // Directories allowed for this run only (agy-mcp-bridge --workspace <dir>); never written to the config file.

package/dist/src/effort.js

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Reasoning effort passed to Antigravity as `--effort`. Lower is faster and thinks less. `default` passes no flag, so Antigravity's own
+ * setting applies. Chosen by the bridge owner in the web UI; read on every task, so a change needs no restart.
+ */
+export const EFFORT_LEVELS = ['default', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const EFFORT_FILE = 'effort.json';
+export const isEffortLevel = (value) => typeof value === 'string' && EFFORT_LEVELS.includes(value);
+export const effortFlags = (level) => level === 'default' ? [] : ['--effort', level];
+/** Anything missing, unreadable or unknown means `default` (no flag). */
+export function readEffort(stateDirectory) {
+    try {
+        const level = JSON.parse(readFileSync(path.join(stateDirectory, EFFORT_FILE), 'utf8')).effort;
+        return isEffortLevel(level) ? level : 'default';
+    }
+    catch {
+        return 'default';
+    }
+}
+export async function writeEffort(stateDirectory, level) {
+    const file = path.join(stateDirectory, EFFORT_FILE);
+    if (level === 'default') {
+        await rm(file, { force: true });
+        return;
+    }
+    await mkdir(stateDirectory, { recursive: true });
+    await writeFile(`${file}.tmp`, JSON.stringify({ effort: level }) + '\n');
+    await rename(`${file}.tmp`, file);
+}
+//# sourceMappingURL=effort.js.map

package/dist/src/models.js

@@ -1,15 +1,20 @@
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { startProcess, terminateOwned } from './antigravity/process.js';
+import { redact } from './security/redact.js';
 export const MODEL_FILE = 'model.json';
 // Ids go straight into the agy command line, so only plain identifier characters are ever accepted (and never a leading dash).
 const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,99}$/;
 export const validModelId = (value) => typeof value === 'string' && MODEL_ID.test(value);
-/** Parses `agy models`: one model per line, the id first, then the display name after two or more spaces. */
+/**
+ * Parses `agy models`: one model per line, the id first, then the display name. In a terminal the columns are padded with spaces; when
+ * the output is piped (as the bridge reads it) they are separated by a single tab, and a progress line ("Fetching available models...") comes first.
+ */
 export function parseModels(text) {
     const models = [];
-    for (const line of text.split(/\r?\n/)) {
-        const match = line.match(/^(\S+)\s{2,}(.+?)\s*$/);
+    // eslint-disable-next-line no-control-regex
+    for (const line of text.replace(/\u001b\[[0-9;]*[A-Za-z]/g, '').split(/\r?\n/)) {
+        const match = line.match(/^(\S+)(?:[ ]*\t[ \t]*|[ ]{2,})(\S.*?)\s*$/);
         if (match && validModelId(match[1]) && !models.some(model => model.id === match[1]))
             models.push({ id: match[1], label: match[2].slice(0, 100) });
     }
@@ -20,19 +25,25 @@ export function listModels(executable, cwd, extraEnvPassthrough = []) {
     return new Promise((resolve, reject) => {
         const child = startProcess(executable, ['models'], cwd, { extraEnvPassthrough });
         let text = '';
+        let errors = '';
         let timedOut = false;
         const timer = setTimeout(() => { timedOut = true; void terminateOwned(child).catch(() => { }); }, 10000);
-        const collect = (chunk) => { if (text.length < 32768)
-            text += chunk.toString().slice(0, 32768 - text.length); };
-        child.stdout.on('data', collect);
+        child.stdout.on('data', (chunk) => { if (text.length < 32768)
+            text += chunk.toString().slice(0, 32768 - text.length); });
+        child.stderr.on('data', (chunk) => { if (errors.length < 4096)
+            errors += chunk.toString().slice(0, 4096 - errors.length); });
         child.once('error', error => { clearTimeout(timer); reject(error); });
         child.once('close', code => {
             clearTimeout(timer);
             const models = parseModels(text);
             if (timedOut)
                 reject(new Error('`agy models` timed out'));
-            else if (code !== 0 || !models.length)
-                reject(new Error('`agy models` did not return a model list'));
+            else if (code !== 0 || !models.length) {
+                // Say what came back, so a changed output format is visible in the web UI instead of a bare "did not return a model list".
+                const firstLines = (value) => value.trim().split(/\r?\n/).slice(0, 2).join(' | ');
+                const seen = [firstLines(text), firstLines(errors)].filter(Boolean).join(' | ').replace(/\s+/g, ' ').slice(0, 240);
+                reject(new Error(`\`agy models\` did not return a model list (exit code ${code}${seen ? `; output: ${redact(seen)}` : '; no output'})`));
+            }
             else
                 resolve(models);
         });

package/dist/src/runtime.js

@@ -30,7 +30,7 @@ export async function createRuntime() {
         supported: { delegate: cli.supported, status: true, wait: true, output: true, cancel_owned_process: true, detached_resume: false },
         allowed_workspaces: config.allowed_workspaces, session_workspaces: sessionOnlyWorkspaces(),
         authentication: 'Cached CLI authentication required; only a live task verifies it.',
-        limits: { max_timeout_seconds: config.max_timeout_seconds, max_output_bytes_per_stream: config.max_output_bytes, max_retained_tasks: config.max_retained_tasks, concurrent_tasks: 1, max_queued_tasks: config.max_queued_tasks },
+        limits: { max_timeout_seconds: config.max_timeout_seconds, max_output_bytes_per_stream: config.max_output_bytes, max_retained_tasks: config.max_retained_tasks, concurrent_tasks: 1, max_queued_tasks: config.max_queued_tasks, max_wait_seconds: manager.maxWaitSeconds },
         limitations: [
             'Only agy 1.4.x with all required flags is enabled; real agent execution was verified on 1.4.3.',
             ...cli.warnings,

package/dist/src/security/input.js

@@ -7,9 +7,10 @@ export const delegateSchema = z.object({
     timeout_seconds: z.number().int().min(1).max(900).optional()
 }).strict().refine(input => JSON.stringify(input).length <= 24000 && !JSON.stringify(input).includes('\\u0000'), 'Combined task data must fit 24000 characters and contain no NUL characters');
 export const taskIdSchema = z.object({ task_id: z.uuid() }).strict();
-// Kept below the 60s tool timeout recommended for Codex so a wait never outlives the client call.
-export const MAX_WAIT_SECONDS = 25;
-export const DEFAULT_WAIT_SECONDS = 20;
+// A wait must end before the client's tool timeout (60s by default in Codex), so the default cap sits just below it. Raise `max_wait_seconds`
+// in the config together with the client's tool timeout to let one call cover a long task (fewer calls, fewer tokens).
+export const DEFAULT_MAX_WAIT_SECONDS = 55;
+export const MAX_WAIT_SECONDS = 3600;
 export const waitSchema = z.object({ task_id: z.uuid(), wait_seconds: z.number().int().min(1).max(MAX_WAIT_SECONDS).optional() }).strict();
 export function promptFor(input, client) {
     return [

package/dist/src/tasks/manager.js

@@ -2,13 +2,14 @@ import { existsSync } from 'node:fs';
 import { mkdir, readdir, readFile, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
-import { delegateSchema, promptFor } from '../security/input.js';
+import { DEFAULT_MAX_WAIT_SECONDS, delegateSchema, promptFor } from '../security/input.js';
 import { validateWorkspace } from '../security/workspace.js';
 import { redact } from '../security/redact.js';
 import { delegationState } from '../delegation.js';
 import { startProcess, terminateOwned } from '../antigravity/process.js';
 import { invocationFor, finalEnvelope } from '../antigravity/invocation.js';
 import { helperDirectory } from '../paths.js';
+import { effortFlags, readEffort } from '../effort.js';
 import { lowerLevel, permissionFlags, permissionState } from '../permissions.js';
 import { listModels, readModel } from '../models.js';
 import { pidAlive, recoverExecutionLock } from './execution-lock.js';
@@ -74,7 +75,8 @@ export class TaskManager {
                 context: input.context === undefined ? null : redact(input.context), timeout_seconds: timeout,
                 client: meta.client ? redact(meta.client).slice(0, 100) : null,
                 model: await readModel(this.runtime.stateDirectory),
-                permission: permissionState(this.runtime.stateDirectory).level
+                permission: permissionState(this.runtime.stateDirectory).level,
+                effort: readEffort(this.runtime.stateDirectory)
             }
         };
         this.entries.set(task.task_id, entry);
@@ -149,7 +151,7 @@ export class TaskManager {
             const permission = lowerLevel(entry.request?.permission ?? 'default', permissionState(this.runtime.stateDirectory).level);
             if (entry.request)
                 entry.request.permission = permission;
-            const invocation = invocationFor(promptFor({ ...input, workspace }, entry.request?.client), timeout, this.config.prompt_transport, entry.request?.model ?? null, permissionFlags(permission));
+            const invocation = invocationFor(promptFor({ ...input, workspace }, entry.request?.client), timeout, this.config.prompt_transport, entry.request?.model ?? null, [...permissionFlags(permission), ...effortFlags(entry.request?.effort ?? 'default')]);
             const options = { extraEnvPassthrough: this.config.extra_env_passthrough, stdin: invocation.stdin };
             const child = this.runtime.launch ? this.runtime.launch(invocation.args, workspace, options) : startProcess(this.runtime.executable, invocation.args, workspace, options);
             entry.child = child;
@@ -340,6 +342,8 @@ export class TaskManager {
         const lastOutputAt = this.entries.get(id)?.lastOutputAt;
         return { task, request, prompt, activity: { last_output_at: lastOutputAt ? new Date(lastOutputAt).toISOString() : null } };
     }
+    /** Longest single wait a client may ask for. */
+    get maxWaitSeconds() { return this.config.max_wait_seconds ?? DEFAULT_MAX_WAIT_SECONDS; }
     /** Bounded long-poll: returns as soon as the task ends, or after `seconds` if it is still running. */
     async waitFor(id, seconds) {
         const entry = this.entries.get(id);

package/dist/src/tools/register.js

@@ -1,7 +1,7 @@
 import { CLIENT_INFO_META_KEY, McpServer } from '@modelcontextprotocol/server';
 import { requestContext } from '../request-context.js';
 import * as z from 'zod/v4';
-import { DEFAULT_WAIT_SECONDS, MAX_WAIT_SECONDS, delegateSchema, taskIdSchema, waitSchema } from '../security/input.js';
+import { delegateSchema, taskIdSchema, waitSchema } from '../security/input.js';
 import { redact } from '../security/redact.js';
 import { readPackageInfo } from '../update.js';
 /** Best-effort label for who delegated: the client's declared name/version when the request carries it, else the HTTP User-Agent. */
@@ -36,10 +36,10 @@ export function createServer(manager, environment) {
         inputSchema: taskIdSchema, annotations: { readOnlyHint: true, openWorldHint: false }
     }, async ({ task_id }) => guard(() => manager.summary(task_id)));
     server.registerTool('antigravity_task_wait', {
-        description: `Wait up to wait_seconds (1-${MAX_WAIT_SECONDS}, default ${DEFAULT_WAIT_SECONDS}) for the task to finish, then return its status without logs. Returns early when the task ends; if still running, call again. Does not cancel the task.`,
+        description: `Wait up to wait_seconds (1-${manager.maxWaitSeconds}, default ${manager.maxWaitSeconds}) for the task to finish, then return its status without logs. Returns early when the task ends; if still running, call again. Does not cancel the task.`,
         inputSchema: waitSchema, annotations: { readOnlyHint: true, openWorldHint: false }
     }, async ({ task_id, wait_seconds }) => guard(async () => {
-        await manager.waitFor(task_id, wait_seconds ?? DEFAULT_WAIT_SECONDS);
+        await manager.waitFor(task_id, Math.min(wait_seconds ?? manager.maxWaitSeconds, manager.maxWaitSeconds));
         return manager.summary(task_id);
     }));
     server.registerTool('antigravity_task_output', {

package/dist/src/ui/routes.js

@@ -7,6 +7,7 @@ import { paths } from '../paths.js';
 import { knownUpdate, readPackageInfo } from '../update.js';
 import { workspaceChanges } from '../changes.js';
 import { validModelId, writeModel } from '../models.js';
+import { EFFORT_LEVELS, isEffortLevel, readEffort, writeEffort } from '../effort.js';
 import { PERMISSION_LEVELS, isPermissionLevel, needsAcknowledgement, permissionState, writePermission } from '../permissions.js';
 import { inside } from '../security/workspace.js';
 const assets = {
@@ -55,6 +56,7 @@ async function overview(ctx) {
         delegation: { ...state, controllable: delegationControllable() },
         model: await ctx.manager.currentModel(),
         permission: permissionState(ctx.manager.stateDirectory),
+        effort: readEffort(ctx.manager.stateDirectory),
         queue: ctx.manager.overview().queue,
         warnings: [await ctx.manager.lockDiagnostic()].filter(Boolean),
         update: knownUpdate() && { ...knownUpdate(), package: readPackageInfo().name, command: 'agy-mcp-bridge update' },
@@ -166,6 +168,16 @@ export async function handleUi(req, res, ctx) {
             json(res, 200, { ...delegationState(ctx.manager.stateDirectory), controllable: true });
             return true;
         }
+        if (pathname === '/ui/api/effort' && method === 'POST') {
+            const body = await readJson(req);
+            if (!isEffortLevel(body.effort)) {
+                json(res, 400, { error: `effort must be one of: ${EFFORT_LEVELS.join(', ')}` });
+                return true;
+            }
+            await writeEffort(ctx.manager.stateDirectory, body.effort);
+            json(res, 200, { effort: body.effort });
+            return true;
+        }
         if (pathname === '/ui/api/permission' && method === 'POST') {
             const body = await readJson(req);
             if (!isPermissionLevel(body.level)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-mcp-bridge",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Local authenticated HTTP MCP bridge that lets Codex and Claude Code delegate bounded coding tasks to the Antigravity CLI (agy)",
   "license": "MIT",
   "keywords": [

package/skills/antigravity-bridge/SKILL.md

@@ -58,7 +58,7 @@ Replace example paths and symbols with the user's actual authorized project. `co
 
 ## Observe and reconnect
 
-Prefer `antigravity_task_wait` with `{"task_id":"the-returned-UUID","wait_seconds":20}`: it returns as soon as the task ends, or after at most 25 seconds with `running`, so call it again while the task is within its deadline. `antigravity_task_status` is an instant, log-free snapshot for quick checks. Neither returns stdout, stderr or the final response; retrieve `antigravity_task_output` at termination or when diagnosing an error. Output/status calls return snapshots, not a completion wait.
+Prefer `antigravity_task_wait` with `{"task_id":"the-returned-UUID"}` and no `wait_seconds` (or the largest value the tool description allows, also `limits.max_wait_seconds` in the environment): it returns as soon as the task ends, or at that limit with `running`, so call it again while the task is within its deadline. Every call costs tokens, so use few long waits and do not narrate or call `antigravity_task_status` between them; the user can watch progress in the web UI. If a wait fails with a client timeout, the client's tool timeout is shorter than the bridge's wait limit: tell the user once (raise the client's tool timeout or lower `max_wait_seconds`) and continue with shorter `wait_seconds`. `antigravity_task_status` is an instant, log-free snapshot for quick checks. Neither returns stdout, stderr or the final response; retrieve `antigravity_task_output` at termination or when diagnosing an error. Output/status calls return snapshots, not a completion wait.
 
 Client disconnect does not cancel an accepted task. Reconnect to the same running server and query the saved ID; `recent_tasks` in environment can recover IDs if the delegate reply was lost. If several tasks could match, inspect their status/output before deciding which is yours. Do not resubmit just because a response was lost: submission is not idempotent. Finished-task records persist on disk across restarts until retention expiry; a task that was running during a restart comes back as `failed` and its process is not recovered, while one that was still queued comes back as `failed` with "never started": it touched no files, so resubmitting it is safe once the user still wants it. Unknown/expired ID does not prove the task never ran; inspect workspace changes and reconcile before another submission.
 

package/skills/known-versions.json

@@ -32,6 +32,10 @@
     {
       "sha256": "65c0a72bb016ee8d891bfea17ea5d972dc79dc7c12c57edb17c1e6e8bbd37078",
       "note": "Antigravity permission level is the owner's setting (agy_permissions)"
+    },
+    {
+      "sha256": "066f499ccd7341c7f77c2a409b3632e4cefe16e45ed2c77e75c8154028e951f9",
+      "note": "long waits (limits.max_wait_seconds), fewer polling calls"
     }
   ]
 }

package/ui/app.js

@@ -175,6 +175,18 @@ async function setPermission(level) {
   try { await api('permission', {method: 'POST', body: {level, acknowledge_risk: risky}}); notify('Đã đổi quyền cho các task mới'); await refresh(); }
   catch (error) { notify(error.message); await refresh(); }
 }
+const EFFORT_LEVELS = [
+  {id: 'default', title: 'Mặc định của Antigravity', text: 'Không truyền --effort; Antigravity dùng mức đã cấu hình.'},
+  {id: 'low', title: 'Thấp (nhanh nhất)', text: 'Suy luận ít nhất, phản hồi nhanh. Hợp việc nhỏ, rõ ràng.'},
+  {id: 'medium', title: 'Vừa', text: 'Cân bằng giữa tốc độ và độ kỹ.'},
+  {id: 'high', title: 'Cao', text: 'Suy luận kỹ hơn, chậm hơn.'},
+  {id: 'xhigh', title: 'Rất cao', text: 'Rất kỹ, khá chậm.'},
+  {id: 'max', title: 'Tối đa (chậm nhất)', text: 'Suy luận sâu nhất, chậm nhất.'}
+];
+async function setEffort(effort) {
+  try { await api('effort', {method: 'POST', body: {effort}}); notify('Đã đổi mức suy luận cho các task mới'); await refresh(); }
+  catch (error) { notify(error.message); await refresh(); }
+}
 async function copy(text) {
   try { await navigator.clipboard.writeText(text); notify('Đã sao chép'); } catch { notify('Không thể sao chép tự động'); }
 }
@@ -293,7 +305,7 @@ function detailView() {
   const facts = h('dl', {class: 'kv'},
     ...[['Gửi lúc', clock(task.queued_at || task.started_at)], ['Bắt đầu chạy', queued ? 'Chưa chạy' : clock(task.started_at)], ['Kết thúc', clock(task.ended_at)],
       ['Thời gian chạy', running ? elapsedEl(task.started_at) : queued ? '—' : duration(task.duration_ms)],
-      ['Giới hạn', request ? `${request.timeout_seconds}s` : '—'], ['Model', request && 'model' in request ? request.model || 'mặc định' : '—'], ['Quyền', request && request.permission ? (PERMISSION_LEVELS.find(l => l.id === request.permission)?.title || request.permission) : '—'], ['Exit code', task.exit_code ?? '—'], ['PID', task.pid ?? '—'],
+      ['Giới hạn', request ? `${request.timeout_seconds}s` : '—'], ['Model', request && 'model' in request ? request.model || 'mặc định' : '—'], ['Quyền', request && request.permission ? (PERMISSION_LEVELS.find(l => l.id === request.permission)?.title || request.permission) : '—'], ['Effort', request && request.effort ? request.effort : '—'], ['Exit code', task.exit_code ?? '—'], ['PID', task.pid ?? '—'],
       ['CLI status', task.cli_status ?? '—']].map(([k, v]) => h('div', {}, h('dt', {text: k}), h('dd', {}, typeof v === 'string' || typeof v === 'number' ? String(v) : v))));
 
   const asker = request?.client ? `Tech Lead · ${request.client}` : 'Tech Lead (Codex / Claude)';
@@ -360,6 +372,15 @@ function modelCard(o) {
     loaded?.error ? h('div', {class: 'callout warn', text: `Không lấy được danh sách model: ${loaded.error}`}) : null,
     h('p', {text: 'Áp dụng cho task mới, không cần khởi động lại. Task đang chạy hoặc đang chờ giữ model đã chốt lúc nhận. Danh sách lấy từ `agy models`; model được ghi lại trong từng task.'}));
 }
+function effortCard(o) {
+  const current = EFFORT_LEVELS.find(level => level.id === (o.effort || 'default')) || EFFORT_LEVELS[0];
+  const select = h('select', {class: 'select', 'aria-label': 'Mức suy luận cho task mới', onchange: event => setEffort(event.target.value)},
+    EFFORT_LEVELS.map(level => h('option', {value: level.id, text: level.title})));
+  select.value = current.id;
+  return h('section', {class: 'card panel wide'}, h('h2', {text: 'Mức suy luận (effort)'}),
+    h('div', {class: 'switch-row'}, h('div', {}, h('strong', {text: current.title}), h('span', {class: 'muted', text: current.text})), select),
+    h('p', {text: 'Truyền --effort cho Antigravity. Mức thấp giúp task nhanh hơn nhưng suy luận ít hơn. Áp dụng cho task mới, không cần khởi động lại; mỗi task ghi lại mức đã dùng. Chưa kiểm chứng với agy thật ở chế độ --print.'}));
+}
 function permissionCard(o) {
   const p = o.permission || {level: 'default', controllable: true};
   return h('section', {class: 'card panel wide'}, h('h2', {text: 'Quyền của Antigravity'}),
@@ -382,6 +403,7 @@ function settingsView(o) {
         delegation.controllable ? h('p', {text: 'Tắt để buộc Codex / Claude tự làm. Task đang chạy hoặc đang chờ không bị dừng, nhưng task đang chờ sẽ bị hủy khi đến lượt. Có hiệu lực ngay, không cần khởi động lại.'})
           : h('div', {class: 'callout warn', text: 'Đang bị khóa bởi biến môi trường BRIDGE_DELEGATION. Đổi biến rồi khởi động lại server để mở.'})),
       modelCard(o),
+      effortCard(o),
       permissionCard(o),
       h('section', {class: 'card panel'}, h('h2', {text: 'Kết nối'}),
         h('div', {class: 'copy-row'}, h('code', {text: o.server.mcp_endpoint}), h('button', {class: 'btn small', onclick: () => copy(o.server.mcp_endpoint), text: 'Sao chép'})),
@@ -462,7 +484,7 @@ function patch() {
     if (!rebuilt) patchLogs();
   } else {
     if (!state.models && !state.modelsLoading) loadModels();
-    setRegion('settings', JSON.stringify([state.models, o.model, o.permission, o.cli, o.delegation, o.limits, o.allowed_workspaces, o.session_workspaces, o.server.mcp_endpoint]), () => settingsView(o));
+    setRegion('settings', JSON.stringify([state.models, o.model, o.permission, o.effort, o.cli, o.delegation, o.limits, o.allowed_workspaces, o.session_workspaces, o.server.mcp_endpoint]), () => settingsView(o));
   }
   tick();
 }