agy-mcp-bridge 0.1.12 → 0.1.13

package/README.md

@@ -399,10 +399,18 @@ 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ị).
+
 **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,7 @@ 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 { 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 +164,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 +197,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 +211,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 +300,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 +320,7 @@ 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);
                         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 +339,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';
                     }
                 }
@@ -413,7 +464,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 +475,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). */

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 { readProgress, writeProgress } from '../progress.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 +61,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),
@@ -172,6 +174,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/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.13",
   "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,6 @@ 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; }

package/ui/app.js

@@ -70,6 +70,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 +240,10 @@ 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(); }
+}
 async function copy(text) {
   try { await navigator.clipboard.writeText(text); notify('Đã sao chép'); } catch { notify('Không thể sao chép tự động'); }
 }
@@ -371,6 +396,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 +430,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);
@@ -466,6 +501,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'}),
@@ -546,9 +582,10 @@ function patch() {
     setRegion('detail', detailKey, () => detailView());
     if (!rebuilt) patchLogs();
     patchActivity();
+    patchSteps();
   } 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();
 }