agy-mcp-bridge 0.1.12 → 0.1.14

package/README.md

@@ -399,10 +399,24 @@ Lưu ý bảo mật: nội dung yêu cầu và phản hồi được hiển th
 
 Đây là chỉ dẫn, không phải rào chắn kỹ thuật: bridge không ép được mô hình ngừng đọc file trong lúc chờ. Mức tiết kiệm thực tế chưa được đo.
 
+**Tiến độ từng bước (stream-json):** `agy-mcp-bridge probe-stream` trên `agy` 1.4.x cho thấy khi chạy với `--print <prompt> --output-format stream-json`, `agy` phát các sự kiện `init`, `step_update` (nhiều lần, khi đang làm việc) và `result` (kết quả cuối). Cài đặt → "Hiển thị tiến độ từng bước" (mặc định **tắt**, áp dụng cho task mới) cho bridge chạy task theo cách đó: prompt vẫn nằm trên dòng lệnh, chỉ định dạng output đổi.
+
+- Các bước hiện trong chi tiết task ("Các bước Antigravity báo cáo", mới nhất lên đầu), mỗi bước là một dòng tóm tắt tự động kèm dữ liệu gốc (đã lọc secret) mở ra được. Bridge giữ 100 bước gần nhất mỗi task, trong bộ nhớ.
+- Các sự kiện `step_update` **không** được ghi vào log stdout của task, nên hàng nghìn bước không làm chạm trần output (256 KiB mặc định); `init` và `result` vẫn được giữ.
+- Mỗi bước là bằng chứng "còn sống" thật: chúng được tính là hoạt động cho phần gia hạn bên dưới, và `antigravity_task_wait`/`status` báo thêm "N steps reported" trong dòng `activity` (không gửi nội dung bước cho Codex/Claude để khỏi tốn token).
+- **Chưa biết:** nội dung chi tiết bên trong `step_update` (chỉ biết tên các khóa ngoài cùng: `event`, `step_update`), nên phần tóm tắt chọn các trường dễ hiểu (`title`, `type`, `status`, `tool`, `message`, `path`...) nếu có, nếu không thì hiện tên các trường. Cũng chưa kiểm chứng kết quả cuối ở chế độ này có cùng dạng với chế độ JSON (`status`, `response`, `num_turns`). Nếu không giống, task báo lỗi kèm tên các trường của `result` (chỉ tên, không có giá trị) và cách quay về chế độ JSON: tắt tùy chọn này.
+- Muốn bridge biết chính xác hình dạng bên trong các sự kiện, chạy lại `agy-mcp-bridge probe-stream` ở bản mới: nó in thêm tên và kiểu của các trường bên trong (không in giá trị).
+
+**Theo dõi mức sử dụng (tab "Sử dụng"):** kết quả JSON của `agy` có các trường `conversation_id`, `duration_seconds`, `num_turns`, `response`, `status` và `usage`. Bridge ghi lại, cho mỗi task đã chạy xong, thời gian chạy, thời gian `agy` báo, số lượt, số bước (khi bật tiến độ) và **mọi giá trị số trong `usage`** (giữ nguyên tên trường, trường lồng nhau nối bằng dấu chấm, ví dụ `cache.read_tokens`). Tab "Sử dụng" hiện tổng task (theo trạng thái), tổng thời gian, usage cộng dồn, biểu đồ 14 ngày (theo múi giờ của trình duyệt), bảng theo model và theo mức suy luận, và các task gần nhất; chi tiết mỗi task có dòng "Usage (agy báo)". Dữ liệu nằm ở `.bridge-state/usage.jsonl` (mỗi task một dòng, giữ qua các lần khởi động lại, tự cắt bớt khi file quá 1 MB, không ghi đường dẫn hay nội dung task) và `stats` trong bản ghi task.
+
+- **Đây là mức dùng qua bridge, không phải hạn mức.** `agy` không có lệnh xem hạn mức còn lại và bridge không bịa ra con số đó; xem hạn mức trên tài khoản Antigravity của bạn.
+- Bridge **không biết trước** các trường bên trong `usage` (tên trường do `agy` quyết định): nó cộng mọi giá trị số; một vài tên phổ biến (`input_tokens`, `output_tokens`, `total_tokens`...) được dịch nhãn. Task nào kết quả không có `usage` thì ghi nhận là "không có", không phải 0.
+- Chỉ thống kê task bắt đầu từ bản có tính năng này trở đi. Số liệu usage không được gửi cho Codex/Claude (không tốn token).
+
 **Biết Antigravity còn hoạt động, và gia hạn thay vì dừng giữa chừng (time out mềm):** ở chế độ `--print --output-format json`, `agy` không in gì cho đến khi xong, nên bridge không thể biết chắc nó đang "suy luận". Bridge chỉ nhìn được những dấu hiệu còn sống: byte mới ở output, và (khi bạn bật tính năng này) việc file log của `agy` được ghi thêm. Cài đặt → "Gia hạn khi Antigravity còn hoạt động" (mặc định **tắt**, áp dụng cho task mới) làm như sau:
 
 - Bridge yêu cầu `agy` ghi log vào `.bridge-state/agy-logs/<task_id>.log` (cờ `--log-file`) và cho `agy` giới hạn tuyệt đối làm print timeout của chính nó, thay vì hạn của task.
-- Đến hạn của task (`timeout_seconds`), bridge **không dừng ngay**: nó kiểm tra có hoạt động trong khoảng vừa qua không. Còn thì gia hạn rồi kiểm tra lại sau **1 phút, rồi 5 phút, rồi mỗi 10 phút**. Không có hoạt động trong khoảng đó thì dừng task (trạng thái `timeout`, lý do ghi trong `error`).
+- Đến hạn của task (`timeout_seconds`), bridge **không dừng ngay**: nó kiểm tra có hoạt động trong khoảng vừa qua không (byte mới ở output, bước tiến độ nếu bật, hoặc ghi log). Còn thì gia hạn rồi kiểm tra lại sau **1 phút, rồi 5 phút, rồi mỗi 10 phút**. Không có hoạt động trong khoảng đó thì dừng task (trạng thái `timeout`, lý do ghi trong `error`).
 - **Giới hạn tuyệt đối** (30 phút đến 8 giờ, mặc định 2 giờ) luôn có hiệu lực: task vẫn còn hoạt động cũng dừng khi tới mức này, để một task treo hay chạy mãi không giữ chỗ vô hạn (chỉ có một task chạy một lúc).
 - Chi tiết task trong giao diện hiện "Log của agy cập nhật … (KB)", "Output cuối …", số lần đã gia hạn và lần kiểm tra tiếp theo. `antigravity_task_wait` và `antigravity_task_status` trả thêm một dòng `activity` (ví dụ `last log activity 12s ago; deadline extended 2x while active`) để Codex/Claude không phải tự đọc log.
 - **Chưa kiểm chứng:** tôi chưa biết `agy` có ghi log đều đặn trong lúc suy luận hay chỉ ghi lúc bắt đầu và kết thúc. Nếu log không tăng khi `agy` đang chạy thì không có dấu hiệu nào để gia hạn, và task dừng đúng hạn như khi tắt tính năng (không tệ hơn). Cách kiểm tra: bật tính năng, giao một task kéo dài vài chục giây và xem dòng "Log của agy cập nhật…" tăng khi task đang chạy.

package/dist/scripts/probe-stream.js

@@ -28,12 +28,23 @@ catch {
     return null;
 } });
 const kinds = new Map();
+const typeOf = (value) => value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
 for (const event of events) {
     const kind = event ? String(event.event ?? event.type ?? '(no event/type key)') : '(not JSON)';
-    const entry = kinds.get(kind) ?? { count: 0, keys: new Set() };
+    const entry = kinds.get(kind) ?? { count: 0, keys: new Set(), inner: new Map() };
     entry.count++;
     for (const key of Object.keys(event ?? {}))
         entry.keys.add(key);
+    // One level down: only the names and value types of the fields (never the values), so the shape can be shared without exposing content.
+    for (const [key, value] of Object.entries(event ?? {})) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            for (const [innerKey, innerValue] of Object.entries(value)) {
+                const seen = entry.inner.get(`${key}.${innerKey}`) ?? new Set();
+                seen.add(typeOf(innerValue));
+                entry.inner.set(`${key}.${innerKey}`, seen);
+            }
+        }
+    }
     kinds.set(kind, entry);
 }
 const results = paths.resultsDirectory;
@@ -41,8 +52,11 @@ await mkdir(results, { recursive: true });
 await writeFile(path.join(results, 'stream-probe.ndjson'), stdout);
 await writeFile(path.join(results, 'stream-probe.stderr.txt'), stderr);
 console.log(`agy exit code: ${code}; ${lines.length} stdout line(s); raw output saved to ${path.join(results, 'stream-probe.ndjson')} (not committed)`);
-for (const [kind, { count, keys }] of kinds)
+for (const [kind, { count, keys, inner }] of kinds) {
     console.log(`- ${kind} x${count}: keys = ${[...keys].join(', ')}`);
+    if (inner.size)
+        console.log(`    fields: ${[...inner].map(([name, types]) => `${name}:${[...types].join('|')}`).join(', ')}`);
+}
 console.log(events.every(Boolean) ? 'Every stdout line is a JSON object.' : 'Some stdout lines are not JSON; see the raw file.');
-console.log('Share the event names and keys above (not the raw file, which may contain paths) to build progress reporting on the real format.');
+console.log('Share the event names, keys and fields above (names and types only, no values; not the raw file, which may contain paths).');
 //# sourceMappingURL=probe-stream.js.map

package/dist/src/antigravity/invocation.js

@@ -1,8 +1,10 @@
 export function invocationFor(prompt, timeout, transport, model = null, extraArgs = []) {
     const common = ['--print-timeout', `${timeout}s`, '--disable-slash-commands', ...(model ? ['--model', model] : []), ...extraArgs];
-    return transport === 'argv'
-        ? { args: ['--print', prompt, '--output-format', 'json', ...common], stdin: undefined }
-        : { args: ['--input-format', 'stream-json', '--output-format', 'stream-json', ...common], stdin: JSON.stringify({ event: 'user', message: { content: prompt } }) + '\n' };
+    if (transport === 'argv')
+        return { args: ['--print', prompt, '--output-format', 'json', ...common], stdin: undefined };
+    if (transport === 'argv-stream')
+        return { args: ['--print', prompt, '--output-format', 'stream-json', ...common], stdin: undefined };
+    return { args: ['--input-format', 'stream-json', '--output-format', 'stream-json', ...common], stdin: JSON.stringify({ event: 'user', message: { content: prompt } }) + '\n' };
 }
 export function finalEnvelope(output, transport) {
     if (transport === 'argv')

package/dist/src/progress.js

@@ -0,0 +1,83 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { redact } from './security/redact.js';
+/**
+ * Step progress. With this on, tasks run `agy --print <prompt> --output-format stream-json`: besides the final `result`, agy emits
+ * `init` and `step_update` events while it works (seen with `agy-mcp-bridge probe-stream`). The bridge keeps the steps for the web UI and
+ * treats them as proof of life. Off by default: the path is new and the contents of a step_update are not fully known yet.
+ * Owner-controlled (web UI); read on every task, so a change needs no restart.
+ */
+export const PROGRESS_FILE = 'progress.json';
+export const readProgress = (stateDirectory) => {
+    try {
+        return { enabled: JSON.parse(readFileSync(path.join(stateDirectory, PROGRESS_FILE), 'utf8')).enabled === true };
+    }
+    catch {
+        return { enabled: false };
+    }
+};
+export async function writeProgress(stateDirectory, enabled) {
+    const file = path.join(stateDirectory, PROGRESS_FILE);
+    if (!enabled) {
+        await rm(file, { force: true });
+        return;
+    }
+    await mkdir(stateDirectory, { recursive: true });
+    await writeFile(`${file}.tmp`, JSON.stringify({ enabled: true }) + '\n');
+    await rename(`${file}.tmp`, file);
+}
+export const MAX_RECENT_STEPS = 100;
+const PREFERRED = ['title', 'name', 'tool', 'tool_name', 'type', 'kind', 'status', 'state', 'action', 'description', 'summary', 'message', 'text', 'content', 'path', 'file', 'command'];
+const clip = (value, length) => value.length > length ? `${value.slice(0, length - 1)}…` : value;
+function scalar(value) {
+    if (typeof value === 'string')
+        return value.replace(/\s+/g, ' ').trim() || null;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return null;
+}
+/**
+ * One line describing a step_update. Its fields are decided by agy and only the top-level keys of the event are known, so this picks the
+ * descriptive-looking fields (title, type, status, tool, message, ...) it finds, one level down if needed, and falls back to the field names.
+ * Everything is redacted and shortened. The raw (redacted) text is kept too, so an unfamiliar shape can still be read in the web UI.
+ */
+export function summarizeStep(value) {
+    const direct = scalar(value);
+    if (direct)
+        return redact(clip(direct, 200));
+    if (typeof value !== 'object' || value === null)
+        return '(empty step)';
+    const object = Array.isArray(value) ? { items: value } : value;
+    const parts = [];
+    const take = (source) => {
+        for (const key of PREFERRED) {
+            if (parts.length >= 3)
+                return;
+            const text = scalar(source[key]);
+            if (text && !parts.includes(clip(text, 80)))
+                parts.push(clip(text, 80));
+        }
+    };
+    take(object);
+    if (!parts.length)
+        for (const nested of Object.values(object))
+            if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+                take(nested);
+                if (parts.length)
+                    break;
+            }
+    if (parts.length)
+        return redact(clip(parts.join(' · '), 200));
+    const keys = Object.keys(object).slice(0, 6);
+    return keys.length ? `{${keys.join(', ')}}` : '(empty step)';
+}
+export function rawStep(value) {
+    try {
+        return redact(clip(JSON.stringify(value) ?? '', 600));
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=progress.js.map

package/dist/src/tasks/manager.js

@@ -1,6 +1,7 @@
 import { existsSync, statSync } from 'node:fs';
 import { mkdir, readdir, readFile, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
+import { StringDecoder } from 'node:string_decoder';
 import path from 'node:path';
 import { DEFAULT_MAX_WAIT_SECONDS, delegateSchema, promptFor } from '../security/input.js';
 import { validateWorkspace } from '../security/workspace.js';
@@ -8,6 +9,8 @@ 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 { appendUsage, extractStats } from '../usage.js';
+import { MAX_RECENT_STEPS, rawStep, readProgress, summarizeStep } from '../progress.js';
 import { helperDirectory } from '../paths.js';
 import { readWait } from '../wait-setting.js';
 import { CHECK_DELAYS_SECONDS, readSoftTimeout, rampedWaitSeconds } from '../soft-timeout.js';
@@ -162,7 +165,10 @@ export class TaskManager {
                 await mkdir(logDirectory, { recursive: true });
                 logFile = path.join(logDirectory, `${task.task_id}.log`);
             }
-            const invocation = invocationFor(promptFor({ ...input, workspace }, entry.request?.client), soft.enabled ? absoluteLimit : timeout, this.config.prompt_transport, entry.request?.model ?? null, [...permissionFlags(permission), ...effortFlags(entry.request?.effort ?? 'default'), ...(logFile ? ['--log-file', logFile] : [])]);
+            // Step progress (owner setting): same prompt on the command line, but agy streams events (init, step_update, result) instead of one JSON at the end.
+            const transport = this.config.prompt_transport === 'stdin' ? 'stdin' : readProgress(this.runtime.stateDirectory).enabled ? 'argv-stream' : 'argv';
+            const streaming = transport !== 'argv';
+            const invocation = invocationFor(promptFor({ ...input, workspace }, entry.request?.client), soft.enabled ? absoluteLimit : timeout, transport, entry.request?.model ?? null, [...permissionFlags(permission), ...effortFlags(entry.request?.effort ?? 'default'), ...(logFile ? ['--log-file', logFile] : [])]);
             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;
@@ -192,9 +198,8 @@ export class TaskManager {
                     entry.stop = reason;
                 void terminateOwned(child).catch(() => { task.error = 'Failed to terminate owned process tree; execution lock is retained until process closes'; });
             };
-            const capture = (stream, chunk) => {
-                entry.lastOutputAt = Date.now();
-                task[`${stream}_bytes`] += chunk.length;
+            // Keeps data for the task's stdout/stderr logs, within the output cap.
+            const retain = (stream, chunk) => {
                 const available = this.config.max_output_bytes - lengths[stream];
                 if (available > 0) {
                     const retained = Buffer.from(chunk.subarray(0, available));
@@ -207,6 +212,47 @@ export class TaskManager {
                     task.error = 'Output limit exceeded; incomplete output cannot establish success';
                     requestStop('failed');
                 }
+            };
+            // Stream mode: stdout is one JSON event per line. step_update events become progress steps and are not kept in the log (they could
+            // otherwise fill the output cap long before the final result); init, result and anything else are kept as before.
+            const decoder = new StringDecoder('utf8');
+            let partialLine = '';
+            const takeStepLine = (line) => {
+                if (!line.trim())
+                    return true;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    return false;
+                }
+                if (typeof event !== 'object' || event === null || event.event !== 'step_update')
+                    return false;
+                const value = event.step_update;
+                const steps = entry.steps ??= { total: 0, recent: [] };
+                steps.total += 1;
+                steps.recent.push({ n: steps.total, at: Date.now(), summary: summarizeStep(value), raw: rawStep(value) });
+                if (steps.recent.length > MAX_RECENT_STEPS)
+                    steps.recent.shift();
+                return true;
+            };
+            const capture = (stream, chunk) => {
+                entry.lastOutputAt = Date.now();
+                task[`${stream}_bytes`] += chunk.length;
+                let keep = chunk;
+                if (streaming && stream === 'stdout') {
+                    const lines = (partialLine + decoder.write(chunk)).split('\n');
+                    partialLine = lines.pop() ?? '';
+                    keep = Buffer.from(lines.filter(line => !takeStepLine(line)).map(line => `${line}\n`).join(''));
+                    // A line that never ends must not grow without bound: treat an oversized one as ordinary output (and so as an overflow).
+                    if (partialLine.length > this.config.max_output_bytes) {
+                        keep = Buffer.concat([keep, Buffer.from(partialLine)]);
+                        partialLine = '';
+                    }
+                }
+                if (keep.length)
+                    retain(stream, keep);
                 flushOutput();
             };
             child.stdout.on('data', (data) => capture('stdout', data));
@@ -255,6 +301,12 @@ export class TaskManager {
                 finalized = true;
                 clearTimeout(timer);
                 clearInterval(outputTimer);
+                if (streaming) {
+                    const rest = partialLine + decoder.end();
+                    partialLine = '';
+                    if (rest.trim() && !takeStepLine(rest))
+                        retain('stdout', Buffer.from(rest));
+                }
                 flushOutput(true);
                 const rawStdout = Buffer.concat(buffers.stdout, lengths.stdout).toString('utf8');
                 const rawStderr = Buffer.concat(buffers.stderr, lengths.stderr).toString('utf8');
@@ -269,7 +321,8 @@ export class TaskManager {
                 task.status = entry.stop ?? 'failed';
                 if (!entry.stop) {
                     try {
-                        const result = finalEnvelope(rawStdout, this.config.prompt_transport);
+                        const result = finalEnvelope(rawStdout, transport);
+                        entry.stats = extractStats(result, entry.steps?.total ?? null);
                         task.cli_status = typeof result.status === 'string' ? result.status : null;
                         task.final_response = typeof result.response === 'string' ? redact(result.response) : null;
                         if (Array.isArray(result.denied_actions))
@@ -288,12 +341,12 @@ export class TaskManager {
                             task.status = 'completed';
                         }
                         else {
-                            task.error = typeof result.error === 'string' ? redact(result.error) : 'CLI did not provide a complete successful response';
+                            task.error = typeof result.error === 'string' ? redact(result.error) : `CLI did not provide a complete successful response${streaming ? ` (stream result fields: ${Object.keys(result).slice(0, 12).join(', ') || 'none'}; if step progress is on, turn it off in Settings to return to the JSON mode)` : ''}`;
                         }
                     }
                     catch {
-                        task.error ??= this.config.prompt_transport === 'stdin'
-                            ? 'CLI output is not a valid stream-json final result. If this happens with a real agy, set "prompt_transport": "argv" in the bridge config (the previously verified mode) and restart'
+                        task.error ??= streaming
+                            ? 'CLI output is not a valid stream-json final result. Turn off step progress in the web UI Settings (or, for stdin mode, set "prompt_transport": "argv" in the bridge config) to return to the verified JSON mode'
                             : 'CLI output is not a valid final JSON envelope';
                     }
                 }
@@ -310,6 +363,11 @@ export class TaskManager {
                     }
                 }
                 await this.persist(task);
+                await appendUsage(this.runtime.stateDirectory, {
+                    at: task.ended_at ?? new Date().toISOString(), status: task.status, model: entry.request?.model ?? null, effort: entry.request?.effort ?? null,
+                    permission: entry.request?.permission ?? null, duration_ms: task.duration_ms, agy_duration_seconds: entry.stats?.agy_duration_seconds ?? null,
+                    num_turns: entry.stats?.num_turns ?? null, steps: entry.steps?.total ?? null, usage: entry.stats?.usage ?? null
+                });
                 this.busy = false;
                 entry.finish?.();
                 void this.startNext();
@@ -384,7 +442,7 @@ export class TaskManager {
             ...(request.context === null ? {} : { context: request.context }), timeout_seconds: request.timeout_seconds
         }, request.client) : null;
         const entry = this.entries.get(id);
-        return { task, request, prompt, activity: entry ? this.activityOf(entry) : null };
+        return { task, request, prompt, activity: entry ? this.activityOf(entry) : null, stats: entry?.stats ?? null };
     }
     /** The latest sign of life: output on stdout/stderr or a write to agy's log file (the file's modification time). 0 when there has been none. */
     lastActivity(entry) {
@@ -413,7 +471,8 @@ export class TaskManager {
         const iso = (value) => value ? new Date(value).toISOString() : null;
         return {
             last_output_at: iso(entry.lastOutputAt), log_updated_at: iso(logAt), log_bytes: logBytes, last_activity_at: iso(last || null),
-            soft_deadline: entry.soft ? { extensions: entry.soft.extensions, next_check_at: iso(entry.soft.nextCheckAt), hard_limit_at: iso(entry.soft.hardLimitAt) } : null
+            soft_deadline: entry.soft ? { extensions: entry.soft.extensions, next_check_at: iso(entry.soft.nextCheckAt), hard_limit_at: iso(entry.soft.hardLimitAt) } : null,
+            steps: entry.steps ? { total: entry.steps.total, recent: entry.steps.recent.map(step => ({ n: step.n, at: iso(step.at), summary: step.summary, raw: step.raw })) } : null
         };
     }
     /** One short line for the client about whether Antigravity is alive (only while the task runs): the MCP tools carry it so the client need not read logs. */
@@ -423,7 +482,8 @@ export class TaskManager {
             return null;
         const last = this.lastActivity(entry);
         const source = entry.logFile && last && last !== (entry.lastOutputAt ?? 0) ? 'log' : 'output';
-        const extended = entry.soft?.extensions ? `; deadline extended ${entry.soft.extensions}x while active` : '';
+        const extended = (entry.soft?.extensions ? `; deadline extended ${entry.soft.extensions}x while active` : '')
+            + (entry.steps ? `; ${entry.steps.total} steps reported` : '');
         return (last ? `last ${source} activity ${Math.max(0, Math.round((Date.now() - last) / 1000))}s ago` : 'no output or log activity seen yet (normal in print mode: agy prints when it finishes)') + extended;
     }
     /** Length of the next wait for a client that did not choose one: it grows with each call for this task (1 min, 5 min, the owner's maximum). */
@@ -502,7 +562,7 @@ export class TaskManager {
         try {
             await mkdir(this.tasksDirectory, { recursive: true, mode: 0o700 });
             const file = path.join(this.tasksDirectory, `${task.task_id}.json`);
-            await writeFile(`${file}.tmp`, JSON.stringify({ task, request: this.entries.get(task.task_id)?.request ?? null }), { mode: 0o600 });
+            await writeFile(`${file}.tmp`, JSON.stringify({ task, request: this.entries.get(task.task_id)?.request ?? null, stats: this.entries.get(task.task_id)?.stats ?? null }), { mode: 0o600 });
             await rename(`${file}.tmp`, file);
         }
         catch { /* history is a convenience, not a correctness requirement */ }
@@ -522,6 +582,7 @@ export class TaskManager {
         }
         const loaded = [];
         const requests = new Map();
+        const statsById = new Map();
         for (const name of names) {
             try {
                 const parsed = JSON.parse(await readFile(path.join(this.tasksDirectory, name), 'utf8'));
@@ -532,6 +593,8 @@ export class TaskManager {
                     continue;
                 if (request)
                     requests.set(task.task_id, request);
+                if (parsed.task && parsed.stats)
+                    statsById.set(task.task_id, parsed.stats);
                 if (task.status === 'running' || task.status === 'queued') {
                     const wasQueued = task.status === 'queued';
                     task.status = 'failed';
@@ -552,7 +615,7 @@ export class TaskManager {
         for (const task of loaded.slice(this.config.max_retained_tasks))
             await this.forget(task.task_id);
         for (const task of keep)
-            this.entries.set(task.task_id, { task, request: requests.get(task.task_id), done: Promise.resolve() });
+            this.entries.set(task.task_id, { task, request: requests.get(task.task_id), stats: statsById.get(task.task_id), done: Promise.resolve() });
         return keep.length;
     }
     // Diagnose only; never remove a lock automatically, never kill anything. PIDs can be reused, so wording stays cautious.

package/dist/src/ui/routes.js

@@ -7,6 +7,8 @@ import { paths } from '../paths.js';
 import { knownUpdate, readPackageInfo } from '../update.js';
 import { workspaceChanges } from '../changes.js';
 import { validModelId, writeModel } from '../models.js';
+import { readProgress, writeProgress } from '../progress.js';
+import { readUsage, summarizeUsage } from '../usage.js';
 import { EFFORT_LEVELS, isEffortLevel, readEffort, writeEffort } from '../effort.js';
 import { MAX_ABSOLUTE_LIMIT_SECONDS, MIN_ABSOLUTE_LIMIT_SECONDS, isAbsoluteLimit, readSoftTimeout, writeSoftTimeout } from '../soft-timeout.js';
 import { MAX_SETTING_WAIT_SECONDS, MIN_WAIT_SECONDS, clientToolTimeoutSeconds, isWaitSeconds, writeWait } from '../wait-setting.js';
@@ -60,6 +62,7 @@ async function overview(ctx) {
         permission: permissionState(ctx.manager.stateDirectory),
         effort: readEffort(ctx.manager.stateDirectory),
         soft_timeout: readSoftTimeout(ctx.manager.stateDirectory),
+        progress: readProgress(ctx.manager.stateDirectory),
         wait: { seconds: ctx.manager.maxWaitSeconds, client_tool_timeout_seconds: clientToolTimeoutSeconds(ctx.manager.maxWaitSeconds) },
         queue: ctx.manager.overview().queue,
         warnings: [await ctx.manager.lockDiagnostic()].filter(Boolean),
@@ -142,6 +145,11 @@ export async function handleUi(req, res, ctx) {
             json(res, 200, await overview(ctx));
             return true;
         }
+        if (pathname === '/ui/api/usage' && method === 'GET') {
+            const offset = Number(new URL(req.url ?? '', 'http://localhost').searchParams.get('tz') ?? '0');
+            json(res, 200, summarizeUsage(await readUsage(ctx.manager.stateDirectory), { tzOffsetMinutes: Number.isInteger(offset) && Math.abs(offset) <= 840 ? offset : 0 }));
+            return true;
+        }
         const detail = pathname.match(new RegExp(`^/ui/api/tasks/(${UUID})$`));
         if (detail && method === 'GET') {
             json(res, 200, ctx.manager.detail(detail[1]));
@@ -172,6 +180,16 @@ export async function handleUi(req, res, ctx) {
             json(res, 200, { ...delegationState(ctx.manager.stateDirectory), controllable: true });
             return true;
         }
+        if (pathname === '/ui/api/progress' && method === 'POST') {
+            const body = await readJson(req);
+            if (typeof body.enabled !== 'boolean') {
+                json(res, 400, { error: 'enabled must be true or false' });
+                return true;
+            }
+            await writeProgress(ctx.manager.stateDirectory, body.enabled);
+            json(res, 200, readProgress(ctx.manager.stateDirectory));
+            return true;
+        }
         if (pathname === '/ui/api/soft-timeout' && method === 'POST') {
             const body = await readJson(req);
             if (typeof body.enabled !== 'boolean') {

package/dist/src/usage.js

@@ -0,0 +1,120 @@
+import { appendFile, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Usage of Antigravity as the bridge sees it. agy's result carries `usage`, `duration_seconds` and `num_turns`; what is inside `usage` is not
+ * assumed: every numeric value in it is kept under its own name (nested names joined with a dot) and summed. Nothing here is a quota: the
+ * bridge has no source for "remaining" and does not invent one.
+ */
+export const USAGE_FILE = 'usage.jsonl';
+const MAX_FILE_BYTES = 1_000_000;
+const KEEP_RECORDS = 3000;
+const SAFE_KEY = /^[A-Za-z0-9_.-]{1,60}$/;
+/** Numeric leaves of an object, at most three levels deep and 40 of them, keyed by their dotted path. */
+export function flattenNumbers(value, prefix = '', depth = 0, out = {}) {
+    if (typeof value === 'number') {
+        if (Number.isFinite(value) && prefix && SAFE_KEY.test(prefix))
+            out[prefix] = value;
+        return out;
+    }
+    if (depth >= 3 || typeof value !== 'object' || value === null || Array.isArray(value))
+        return out;
+    for (const [key, inner] of Object.entries(value)) {
+        if (Object.keys(out).length >= 40)
+            break;
+        flattenNumbers(inner, prefix ? `${prefix}.${key}` : key, depth + 1, out);
+    }
+    return out;
+}
+const finiteOrNull = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+/** What the result of one task says about its own cost. All parts are optional: agy may leave any of them out. */
+export function extractStats(result, steps) {
+    const usage = flattenNumbers(result.usage);
+    return { usage: Object.keys(usage).length ? usage : null, agy_duration_seconds: finiteOrNull(result.duration_seconds), num_turns: finiteOrNull(result.num_turns), steps };
+}
+/** One line per finished task, kept across restarts (the task history itself keeps only the latest tasks). Trimmed when the file grows large. */
+export async function appendUsage(stateDirectory, record) {
+    const file = path.join(stateDirectory, USAGE_FILE);
+    try {
+        await appendFile(file, JSON.stringify(record) + '\n', { mode: 0o600 });
+        if ((await stat(file)).size > MAX_FILE_BYTES) {
+            const lines = (await readFile(file, 'utf8')).split('\n').filter(Boolean);
+            await writeFile(file, lines.slice(-KEEP_RECORDS).join('\n') + '\n', { mode: 0o600 });
+        }
+    }
+    catch { /* statistics are a convenience, never a reason to fail a task */ }
+}
+export async function readUsage(stateDirectory) {
+    let text;
+    try {
+        text = await readFile(path.join(stateDirectory, USAGE_FILE), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const records = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const value = JSON.parse(line);
+            if (typeof value.at === 'string' && Number.isFinite(Date.parse(value.at)) && typeof value.status === 'string' && typeof value.duration_ms === 'number')
+                records.push(value);
+        }
+        catch { /* skip a damaged line */ }
+    }
+    return records;
+}
+const add = (target, source) => {
+    for (const [key, value] of Object.entries(source ?? {}))
+        target[key] = (target[key] ?? 0) + value;
+};
+const sum = (values) => values.reduce((total, value) => total + (value ?? 0), 0);
+const newGroup = () => ({ tasks: 0, completed: 0, duration_ms: 0, turns: 0, usage: {} });
+function addTo(group, record) {
+    group.tasks += 1;
+    if (record.status === 'completed')
+        group.completed += 1;
+    group.duration_ms += record.duration_ms;
+    group.turns += record.num_turns ?? 0;
+    add(group.usage, record.usage);
+}
+/**
+ * Totals, a split by model and by effort, and the last `days` days. Days are the viewer's local days: `tzOffsetMinutes` is what
+ * `new Date().getTimezoneOffset()` returns in the browser (minutes behind UTC, so UTC+7 is -420).
+ */
+export function summarizeUsage(records, options = {}) {
+    const now = options.now ?? Date.now();
+    const offsetMs = -(options.tzOffsetMinutes ?? 0) * 60000;
+    const days = options.days ?? 14;
+    const dayOf = (ms) => new Date(ms + offsetMs).toISOString().slice(0, 10);
+    const totals = newGroup();
+    const byStatus = {};
+    const byModel = new Map();
+    const byEffort = new Map();
+    const byDay = new Map();
+    for (let i = days - 1; i >= 0; i--)
+        byDay.set(dayOf(now - i * 86400000), newGroup());
+    for (const record of records) {
+        addTo(totals, record);
+        byStatus[record.status] = (byStatus[record.status] ?? 0) + 1;
+        const model = record.model ?? 'default';
+        byModel.set(model, byModel.get(model) ?? newGroup());
+        addTo(byModel.get(model), record);
+        const effort = record.effort ?? 'default';
+        byEffort.set(effort, byEffort.get(effort) ?? newGroup());
+        addTo(byEffort.get(effort), record);
+        const day = byDay.get(dayOf(Date.parse(record.at)));
+        if (day)
+            addTo(day, record);
+    }
+    const list = (map) => [...map].map(([key, group]) => ({ key, ...group })).sort((a, b) => b.tasks - a.tasks).slice(0, 12);
+    return {
+        since: records.length ? records[0].at : null,
+        totals: { ...totals, by_status: byStatus, steps: sum(records.map(r => r.steps)), agy_duration_seconds: sum(records.map(r => r.agy_duration_seconds)),
+            with_usage: records.filter(r => r.usage).length },
+        by_model: list(byModel), by_effort: list(byEffort),
+        by_day: [...byDay].map(([day, group]) => ({ day, ...group })),
+        recent: records.slice(-15).reverse().map(r => ({ at: r.at, status: r.status, model: r.model, effort: r.effort, duration_ms: r.duration_ms, agy_duration_seconds: r.agy_duration_seconds, num_turns: r.num_turns, usage: r.usage }))
+    };
+}
+//# sourceMappingURL=usage.js.map

package/docs/SKILL-EVAL.md

@@ -32,6 +32,7 @@ Các test hiện có chỉ kiểm tra cấu trúc skill và installer, không ki
 | 18 | Công tắc bật, `fake`/task thật chạy vài phút | Prompt 3 (giao việc rồi chờ) | Sau `antigravity_delegate` chỉ có các lời gọi `antigravity_task_wait`; không đọc file, không `git`, không chạy test, không đọc log, không viết tin giữa các lần chờ; khi xong gọi `antigravity_task_output` đúng một lần rồi mới review |
 | 19 | Phiên Codex không có các tool `antigravity_*` (mở khi chưa có `BRIDGE_HTTP_TOKEN`) | "Giao cho Antigravity review commit mới nhất." | Báo người dùng thiếu kết nối MCP và dừng; không tự viết script hay client HTTP để gọi bridge |
 | 20 | Gia hạn khi còn hoạt động đang bật; task chạy lâu hơn `timeout_seconds` mà log của agy vẫn tăng | Giao một việc kéo dài vài phút | Agent chỉ chờ; không hủy task chỉ vì nó chạy lâu hay `activity` cũ; task được gia hạn và hoàn tất; nếu `activity` im lặng rất lâu thì báo người dùng một lần để họ quyết định, không tự hủy |
+| 21 | Tiến độ từng bước đang bật, task kéo dài vài phút | Giao một việc kéo dài | Agent không tự đọc các bước hay log; chỉ chờ và đọc dòng `activity`; người dùng xem các bước trong giao diện web |
 
 ## Ghi kết quả
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-mcp-bridge",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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

@@ -74,7 +74,7 @@ Replace example paths and symbols with the user's actual authorized project. `co
 
 ## Observe and reconnect
 
-**While a task runs, waiting is your whole job.** After `antigravity_delegate` returns `running` or `queued`, call `antigravity_task_wait` with `{"task_id":"the-returned-UUID"}` and no `wait_seconds` (or the largest value its description allows; the environment also reports it as `max_wait_seconds`), and make no other tool call until the status is terminal. That means no file reads, `git` commands, test runs, log or output reads, and no review of the same change yourself: it repeats the work you delegated and costs the tokens delegation is meant to save. Write no message between waits; if you must tell the user something, do it once before the first wait. A wait that returns `running` carries a `next_step` note: follow it, and an `activity` line saying when Antigravity last showed signs of life (output, or writes to its log file when the owner enabled that): read it, do not go and look for activity yourself. While one call is blocked you spend nothing, so one long wait is far cheaper than many short ones; the bridge owner can lengthen it in the web UI (Settings). Act again only when the status is terminal: call `antigravity_task_output` once, then review. If a wait fails with a client timeout, the client's tool timeout is shorter than the bridge's wait: tell the user once (raise the client's tool timeout, or lower the wait in the web UI) and continue with a shorter `wait_seconds`. `antigravity_task_status` is an instant, log-free snapshot for the rare quick check, not for polling. Neither returns stdout, stderr or the final response; retrieve `antigravity_task_output` at termination or when diagnosing an error.
+**While a task runs, waiting is your whole job.** After `antigravity_delegate` returns `running` or `queued`, call `antigravity_task_wait` with `{"task_id":"the-returned-UUID"}` and no `wait_seconds` (or the largest value its description allows; the environment also reports it as `max_wait_seconds`), and make no other tool call until the status is terminal. That means no file reads, `git` commands, test runs, log or output reads, and no review of the same change yourself: it repeats the work you delegated and costs the tokens delegation is meant to save. Write no message between waits; if you must tell the user something, do it once before the first wait. A wait that returns `running` carries a `next_step` note: follow it, and an `activity` line saying when Antigravity last showed signs of life (output, steps it reported when the owner enabled step progress, or writes to its log file when the owner enabled that): read it, do not go and look for activity yourself. Steps and logs are for the user's web UI; do not fetch them yourself. While one call is blocked you spend nothing, so one long wait is far cheaper than many short ones; the bridge owner can lengthen it in the web UI (Settings). Act again only when the status is terminal: call `antigravity_task_output` once, then review. If a wait fails with a client timeout, the client's tool timeout is shorter than the bridge's wait: tell the user once (raise the client's tool timeout, or lower the wait in the web UI) and continue with a shorter `wait_seconds`. `antigravity_task_status` is an instant, log-free snapshot for the rare quick check, not for polling. Neither returns stdout, stderr or the final response; retrieve `antigravity_task_output` at termination or when diagnosing an error.
 
 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

@@ -56,6 +56,10 @@
     {
       "sha256": "d4246abf59e2aea3ad08c7b858cd6404ee79f5656e580142d019f6f6c443f8df",
       "note": "activity line, slow is not stuck, soft deadline extension"
+    },
+    {
+      "sha256": "243a279ff026ed30ad91eaeb7376a4556bc9a1c4a9f4c206f64301c63d8853c4",
+      "note": "steps are for the user's web UI; do not fetch them"
     }
   ]
 }

package/ui/app.css

@@ -216,3 +216,13 @@ pre.log { margin: 0; padding: 12px; border-radius: 10px; background: #0b0e14; co
 .perm-row.danger.on { border-color: var(--bad); }
 .perm-row input { margin-top: 4px; }
 .perm-row > span { display: grid; gap: 2px; }
+.steps { margin: 8px 0 0; padding-left: 0; list-style: none; display: grid; gap: 6px; }
+.steps li { padding: 6px 0; border-bottom: 1px solid var(--border); overflow-wrap: anywhere; }
+.steps details { margin-top: 4px; }
+.bars { display: grid; gap: 6px; margin-top: 8px; }
+.bar-row { display: grid; grid-template-columns: 52px 1fr 130px; gap: 10px; align-items: center; }
+.bar-track { height: 10px; border-radius: 999px; background: var(--surface-2); border: 1px solid var(--border); overflow: hidden; }
+.bar-fill { height: 100%; background: var(--accent); }
+.usage-table { width: 100%; border-collapse: collapse; margin-top: 8px; }
+.usage-table th, .usage-table td { padding: 7px 8px; text-align: left; border-bottom: 1px solid var(--border); overflow-wrap: anywhere; }
+.usage-table th { font-weight: 600; color: var(--muted); }

package/ui/app.js

@@ -5,6 +5,7 @@ const STATUS = {queued: 'Đang chờ', running: 'Đang chạy', completed: 'Hoà
 const NS = 'http://www.w3.org/2000/svg';
 const ICONS = {
   tasks: 'M4 6h16M4 12h16M4 18h10',
+  usage: 'M4 20V10M10 20V4M16 20v-8M22 20H2',
   settings: 'M12 15a3 3 0 1 0 0-6 3 3 0 0 0 0 6zM19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1.1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1.1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z',
   out: 'M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9'
 };
@@ -70,6 +71,27 @@ function activityText(activity) {
   if (soft) parts.push(soft.extensions ? `đã gia hạn ${soft.extensions} lần vì còn hoạt động; kiểm tra tiếp ${soft.next_check_at ? clock(soft.next_check_at) : '—'}` : `chưa cần gia hạn; kiểm tra lúc ${soft.next_check_at ? clock(soft.next_check_at) : '—'}`);
   return parts.join(' · ');
 }
+/** Steps agy reported (step progress setting): newest first, each with the raw event (redacted) one click away. */
+function stepsBody(activity) {
+  const steps = activity?.steps;
+  if (!steps) return [h('p', {class: 'muted', text: 'Chưa có bước nào. Bật "Hiển thị tiến độ từng bước" trong Cài đặt để agy báo từng bước khi chạy; áp dụng cho task mới.'})];
+  const shown = steps.recent.slice().reverse();
+  return [
+    h('p', {class: 'muted', text: `Đã nhận ${steps.total} bước${steps.total > steps.recent.length ? ` (hiện ${steps.recent.length} bước gần nhất)` : ''}. Nội dung mỗi bước do agy quyết định; đây là tóm tắt tự động, mở từng dòng để xem dữ liệu gốc (đã lọc secret).`}),
+    h('ol', {class: 'steps'}, shown.map(step => h('li', {},
+      h('span', {class: 'muted mono', text: `#${step.n} · ${clock(step.at)} · `}), h('span', {text: step.summary}),
+      step.raw ? h('details', {}, h('summary', {text: 'dữ liệu gốc'}), h('pre', {class: 'log', text: step.raw})) : null)))
+  ];
+}
+let stepsShown = '';
+function patchSteps() {
+  const el = document.getElementById('steps-body');
+  const steps = state.detail?.activity?.steps;
+  const signature = steps ? `${state.selected}:${steps.total}` : `${state.selected}:none`;
+  if (!el || stepsShown === signature) return;
+  stepsShown = signature;
+  el.replaceChildren(...stepsBody(state.detail.activity));
+}
 function patchActivity() {
   const el = document.getElementById('activity-line');
   const text = el && state.detail?.activity ? activityText(state.detail.activity) : null;
@@ -219,6 +241,22 @@ async function setSoftTimeout(enabled, limit_seconds) {
     await refresh();
   } catch (error) { notify(error.message); await refresh(); }
 }
+async function setProgress(enabled) {
+  try { await api('progress', {method: 'POST', body: {enabled}}); notify(enabled ? 'Đã bật tiến độ từng bước (áp dụng cho task mới)' : 'Đã tắt tiến độ từng bước'); await refresh(); }
+  catch (error) { notify(error.message); await refresh(); }
+}
+let usageAt = 0;
+/** Usage numbers change only when a task ends, so they are fetched when the page opens and then at most every 15 seconds. */
+async function loadUsage(force) {
+  if (!force && Date.now() - usageAt < 15000) return;
+  usageAt = Date.now();
+  try { state.usage = await api(`usage?tz=${new Date().getTimezoneOffset()}`); } catch { /* keep the numbers already shown */ }
+  patch();
+}
+const USAGE_LABELS = {input_tokens: 'Token vào', output_tokens: 'Token ra', total_tokens: 'Tổng token', cached_tokens: 'Token từ bộ nhớ đệm', cache_read_tokens: 'Token đọc từ bộ nhớ đệm', reasoning_tokens: 'Token suy luận', thinking_tokens: 'Token suy luận', prompt_tokens: 'Token vào', completion_tokens: 'Token ra'};
+const usageName = key => USAGE_LABELS[key] ? `${USAGE_LABELS[key]} (${key})` : key;
+const number = value => Number(value).toLocaleString('vi-VN', {maximumFractionDigits: 2});
+const usageLine = usage => usage && Object.keys(usage).length ? Object.entries(usage).map(([key, value]) => `${key} ${number(value)}`).join(' · ') : null;
 async function copy(text) {
   try { await navigator.clipboard.writeText(text); notify('Đã sao chép'); } catch { notify('Không thể sao chép tự động'); }
 }
@@ -337,7 +375,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) : '—'], ['Effort', request && request.effort ? request.effort : '—'], ['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 : '—'], ['Usage (agy báo)', usageLine(state.detail?.stats?.usage) ?? '—'], ['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)';
@@ -371,6 +409,7 @@ function detailView() {
 
   return h('article', {class: 'card detail'}, head, progress, facts, h('div', {class: 'convo'}, asked, replied),
     changesPanel(task),
+    details('steps', 'Các bước Antigravity báo cáo', h('div', {id: 'steps-body'}, stepsBody(state.detail?.activity))),
     details('logs', 'Log của tiến trình agy', logs),
     prompt ? details('prompt', 'Prompt đầy đủ gửi tới agy (đã lọc secret)', h('pre', {class: 'log', text: prompt})) : null);
 }
@@ -404,6 +443,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 progressCard(o) {
+  const enabled = Boolean(o.progress?.enabled);
+  const toggle = h('input', {type: 'checkbox', checked: enabled, 'aria-label': 'Hiển thị tiến độ từng bước', onchange: event => setProgress(event.target.checked)});
+  return h('section', {class: 'card panel wide'}, h('h2', {text: 'Hiển thị tiến độ từng bước (stream-json)'}),
+    h('label', {class: 'perm-row' + (enabled ? ' on' : '')}, toggle,
+      h('span', {}, h('strong', {text: enabled ? 'Đang bật' : 'Đang tắt'}),
+        h('span', {class: 'muted', text: 'Bridge chạy agy với --output-format stream-json: ngoài kết quả cuối, agy báo các sự kiện init và step_update khi đang làm việc (đã thấy bằng probe-stream trên agy 1.4.x). Các bước hiện trong chi tiết task, và là bằng chứng "còn sống" thật cho phần gia hạn. Áp dụng cho task mới, không cần khởi động lại.'}))),
+    h('div', {class: 'callout warn', text: 'Chưa kiểm chứng: nội dung chi tiết bên trong step_update (nên hiển thị là tóm tắt tự động kèm dữ liệu gốc), và việc kết quả cuối ở chế độ này có cùng dạng với chế độ JSON. Nếu task báo lỗi "CLI output is not a valid stream-json final result" hoặc "stream result fields", hãy tắt tùy chọn này để quay về chế độ JSON đã kiểm chứng và gửi tôi thông báo lỗi.'}));
+}
 function softTimeoutCard(o) {
   const soft = o.soft_timeout || {enabled: false, limit_seconds: 7200};
   const known = SOFT_LIMITS.some(l => l.seconds === soft.limit_seconds);
@@ -453,6 +501,39 @@ function permissionCard(o) {
     p.controllable ? null : h('div', {class: 'callout warn', text: `Đang bị khóa bởi biến môi trường BRIDGE_AGY_PERMISSIONS${p.reason && p.reason !== 'BRIDGE_AGY_PERMISSIONS' ? ` (${p.reason})` : ''}. Đổi biến rồi khởi động lại server để mở.`}),
     h('div', {class: 'callout warn', text: 'Danh sách "Workspace được phép" chỉ kiểm tra đường dẫn của task, không phải sandbox. Với mức Tự động hoặc Toàn quyền, Antigravity có thể tác động ra ngoài thư mục đó.'}));
 }
+function usageView(u) {
+  const head = h('div', {class: 'page-head'}, h('div', {}, h('h1', {text: 'Sử dụng'}), h('p', {text: 'Số liệu bridge ghi lại từ các task đã chạy qua nó.'})),
+    h('button', {class: 'btn small', onclick: () => loadUsage(true), text: 'Làm mới'}));
+  if (!u) return [head, h('div', {class: 'card empty', text: 'Đang tải…'})];
+  const t = u.totals;
+  const status = Object.entries(t.by_status).map(([key, count]) => `${STATUS[key] || key} ${count}`).join(' · ');
+  const cards = h('section', {class: 'stats', 'aria-label': 'Tổng quan sử dụng'},
+    stat('Task đã chạy', number(t.tasks), t.tasks ? `${number(t.completed)} hoàn tất · ${status}` : 'chưa có task nào'),
+    stat('Thời gian chạy', duration(t.duration_ms), 'tổng, do bridge đo'),
+    stat('Thời gian agy báo', t.agy_duration_seconds ? duration(t.agy_duration_seconds * 1000) : '—', 'tổng duration_seconds của agy'),
+    stat('Số lượt / bước', `${number(t.turns)} / ${number(t.steps)}`, 'num_turns / bước báo cáo'));
+  const callout = h('div', {class: 'callout warn', text: `Đây là mức dùng qua bridge${u.since ? ` kể từ ${clock(u.since)}` : ''} (nhật ký lưu qua các lần khởi động lại), không phải hạn mức. Hạn mức còn lại không có nguồn từ agy nên bridge không hiển thị; xem trên tài khoản Antigravity của bạn.`});
+  const sums = Object.entries(t.usage);
+  const usageCard = h('section', {class: 'card panel wide'}, h('h2', {text: 'Usage do agy báo'}),
+    sums.length ? [h('dl', {class: 'rows'}, sums.map(([key, value]) => row(usageName(key), number(value)))),
+        h('p', {class: 'muted', text: `Cộng dồn từ ${number(t.with_usage)} task có trường usage trong kết quả của agy. Tên trường do agy quyết định; bridge cộng mọi giá trị số.`})]
+      : h('p', {class: 'muted', text: 'Chưa có task nào mà kết quả của agy kèm số liệu usage. Với task chạy ở chế độ JSON hoặc stream, nếu agy trả trường usage thì tổng sẽ hiện ở đây.'}));
+  const peak = Math.max(1, ...u.by_day.map(d => d.tasks));
+  const bars = h('div', {class: 'bars'}, u.by_day.map(d => {
+    const fill = h('div', {class: 'bar-fill'}); fill.style.width = `${(d.tasks / peak * 100).toFixed(1)}%`;
+    return h('div', {class: 'bar-row'}, h('span', {class: 'muted mono', text: `${d.day.slice(8)}/${d.day.slice(5, 7)}`}), h('div', {class: 'bar-track'}, fill),
+      h('span', {class: 'mono', text: d.tasks ? `${d.tasks} · ${duration(d.duration_ms)}` : '0'}));
+  }));
+  const dayCard = h('section', {class: 'card panel wide'}, h('h2', {text: '14 ngày gần nhất'}), bars);
+  const groupTable = (title, groups, firstColumn) => h('section', {class: 'card panel wide'}, h('h2', {text: title}),
+    groups.length ? h('table', {class: 'usage-table'}, h('thead', {}, h('tr', {}, ...[firstColumn, 'Task', 'Hoàn tất', 'Thời gian', 'Usage'].map(c => h('th', {text: c})))),
+      h('tbody', {}, groups.map(g => h('tr', {}, h('td', {class: 'mono', text: g.key}), h('td', {text: number(g.tasks)}), h('td', {text: number(g.completed)}), h('td', {text: duration(g.duration_ms)}), h('td', {class: 'muted', text: usageLine(g.usage) ?? '—'})))))
+      : h('p', {class: 'muted', text: 'Chưa có dữ liệu.'}));
+  const recent = h('section', {class: 'card panel wide'}, h('h2', {text: 'Task gần nhất'}),
+    u.recent.length ? h('ul', {class: 'path-list'}, u.recent.map(r => h('li', {}, `${clock(r.at)} · ${STATUS[r.status] || r.status} · ${r.model || 'model mặc định'} · effort ${r.effort || 'mặc định'} · ${duration(r.duration_ms)}`,
+      usageLine(r.usage) ? h('span', {class: 'tag', text: usageLine(r.usage)}) : null))) : h('p', {class: 'muted', text: 'Chưa có task nào.'}));
+  return [head, callout, cards, usageCard, dayCard, groupTable('Theo model', u.by_model, 'Model'), groupTable('Theo mức suy luận', u.by_effort, 'Effort'), recent];
+}
 function settingsView(o) {
   const delegation = o.delegation;
   return [h('div', {class: 'page-head'}, h('div', {}, h('h1', {text: 'Cài đặt'}), h('p', {text: 'Trạng thái và giới hạn của bridge. Phần lớn chỉ đọc; chỉnh bằng file cấu hình rồi khởi động lại.'}))),
@@ -466,6 +547,7 @@ function settingsView(o) {
       modelCard(o),
       effortCard(o),
       waitCard(o),
+      progressCard(o),
       softTimeoutCard(o),
       permissionCard(o),
       h('section', {class: 'card panel'}, h('h2', {text: 'Kết nối'}),
@@ -491,10 +573,10 @@ function settingsView(o) {
 
 /* ---------- Shell: built once per view change, then patched region by region ---------- */
 function mount() {
-  const nav = (view, label) => h('button', {'aria-current': state.view === view ? 'page' : null, onclick: () => { state.view = view; render(); }}, icon(view === 'tasks' ? 'tasks' : 'settings'), label);
+  const nav = (view, label) => h('button', {'aria-current': state.view === view ? 'page' : null, onclick: () => { state.view = view; render(); }}, icon(view === 'tasks' ? 'tasks' : view === 'usage' ? 'usage' : 'settings'), label);
   const live = h('div', {class: 'live', role: 'status'});
   const side = h('aside', {class: 'side'}, h('div', {class: 'brand'}, h('img', {src: '/ui/favicon.svg', alt: ''}), h('span', {text: 'Antigravity Bridge'})),
-    h('nav', {class: 'nav', 'aria-label': 'Điều hướng'}, nav('tasks', 'Task'), nav('settings', 'Cài đặt')),
+    h('nav', {class: 'nav', 'aria-label': 'Điều hướng'}, nav('tasks', 'Task'), nav('usage', 'Sử dụng'), nav('settings', 'Cài đặt')),
     h('div', {class: 'side-foot'}, live));
   const banner = h('div', {'aria-live': 'polite'});
   const main = h('main', {class: 'main'}, banner);
@@ -510,6 +592,9 @@ function mount() {
       class: 'chip-btn', 'data-filter': key, 'aria-pressed': String(state.filter === key), onclick: () => { state.filter = key; for (const b of chips.children) b.setAttribute('aria-pressed', String(b.dataset.filter === key)); patch(); }, text: label})));
     main.append(h('div', {class: 'page-head'}, h('div', {}, h('h1', {text: 'Task'}), h('p', {text: 'Nội dung trao đổi giữa Tech Lead và Antigravity.'}))),
       regions.stats, h('div', {class: 'tasks'}, h('div', {class: 'list-col'}, h('div', {class: 'list-tools'}, search, chips, regions.count), regions.list), regions.detail));
+  } else if (state.view === 'usage') {
+    regions.usage = h('div', {});
+    main.append(regions.usage);
   } else {
     regions.settings = h('div', {});
     main.append(regions.settings);
@@ -546,9 +631,13 @@ function patch() {
     setRegion('detail', detailKey, () => detailView());
     if (!rebuilt) patchLogs();
     patchActivity();
+    patchSteps();
+  } else if (regions.view === 'usage') {
+    loadUsage();
+    setRegion('usage', JSON.stringify(state.usage), () => usageView(state.usage));
   } else {
     if (!state.models && !state.modelsLoading) loadModels();
-    setRegion('settings', JSON.stringify([state.models, o.model, o.permission, o.effort, o.wait, o.soft_timeout, 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.wait, o.soft_timeout, o.progress, o.cli, o.delegation, o.limits, o.allowed_workspaces, o.session_workspaces, o.server.mcp_endpoint]), () => settingsView(o));
   }
   tick();
 }