agy-mcp-bridge 0.1.35 → 0.1.36

package/README.md

@@ -66,20 +66,23 @@ Then call `antigravity_environment` from a fresh session — that is the proof;
 | `isolation` | `none` (default — edits the workspace, globally serial) or `worktree` (branch `bridge/<task_id>` under `.bridge-state/worktrees/<task_id>`, parallel up to `max_parallel_worktrees`). Worktree tasks must declare `owns`, and the repo needs at least one commit. Uncommitted changes in the main checkout are **not** copied in. |
 | `owns` | relative paths the agent may touch. After the run the bridge diffs the worktree against this list and reports anything else in `scope.out_of_scope`. It never auto-merges, never deletes the branch, and does not run repo hooks. |
 | `autonomy` | `suggest` \| `auto` \| `full` — an instruction to the CLI agent, not a permission grant. Destructive actions stay hard-denied (see below). |
+| `resume_conversation` | the `conversation_id` of a finished Antigravity task **in the same workspace**: the new task continues that conversation instead of opening one. An agy conversation id names a session on this machine, not inside one project, so the bridge accepts only ids from its own task history and refuses the rest. A task the retention limit dropped can no longer be resumed. |
 
 | Tool | What it does |
 |---|---|
 | `antigravity_environment` | CLI versions, allowlist, limits, agents, parallelism, `recent_tasks`, delegation switch |
-| `agents_list` | probed agents, capabilities, availability, default agent, worktree limits (read-only) |
+| `agents_list` | probed agents, capabilities, availability, default agent, worktree limits, and `conversation_resume` for the agents whose CLI was probed (read-only) |
 | `antigravity_delegate` | accepts a task, returns `running` (or `queued`) with a `task_id` |
 | `antigravity_task_status` | cheap poll: state, pid, elapsed, errors, `denied_actions`, byte counts |
 | `antigravity_task_wait` | blocks up to `wait_seconds` (default cap 55 s), returns early when the task ends |
-| `antigravity_task_output` | final response, stdout/stderr, errors, `denied_actions`, truncation |
+| `antigravity_task_output` | final response, stdout/stderr, errors, `denied_actions`, `conversation_id`, truncation |
 | `antigravity_cancel_task` | kills the task's process tree; does not revert file changes |
 | `code_search` | XERJ passage/definition lookup; registered always but **refused while `xerj.enabled` is off** |
 
 `completed` means the CLI exited with a parseable result — always `review_required: true`, `acceptance_verified: false`. A 0 exit code can still be reported as `failed` after a permission denial or a timeout. While a task runs, `wait`/`status` return a short `activity` line instead of making the client read logs.
 
+Antigravity names each session (`conversation_id`), so a correction can continue the conversation that already read the code instead of re-explaining it: pass that id as `resume_conversation`. The token cost is the honest part — `agy` re-sends the whole conversation every turn. Measured on `agy` 1.4.12 with the bridge's own flags: a first turn cost 6.107 input tokens beside 12.223 cached, the resumed turn 8.394 input beside 28.500 cached. Continuing is cheap compared with writing the same context into a new task, but it is not free. Codex and OpenCode tasks start fresh: the bridge reads no session id out of their output, so it records none and offers no resume. That is a statement about what the bridge parses, not a claim that those CLIs cannot continue a session.
+
 Two switches control delegation itself: `agy-mcp-bridge delegation off` blocks new tasks immediately without a restart, and `BRIDGE_DELEGATION=off` pins it at startup. Tasks still refuse to be delegated by policy the skill describes (security, auth, secrets, data deletion, deploy, CI and public API changes are not delegated).
 
 ## Agents, profiles and pools

package/dist/src/agents/antigravity.js

@@ -10,7 +10,7 @@ export function antigravityAdapter(executable, defaultTransport, options = {}) {
         capabilities: CAPABILITIES,
         buildInvocation(task) {
             const transport = task.promptTransport ?? defaultTransport;
-            const invocation = invocationFor(task.prompt, task.timeoutSeconds, transport, task.model ?? null, task.extraArgs ?? []);
+            const invocation = invocationFor(task.prompt, task.timeoutSeconds, transport, task.model ?? null, task.extraArgs ?? [], task.conversationId ?? null);
             return { executable, args: invocation.args, stdin: invocation.stdin, transport, customEnv: options.env };
         },
         async parseResult(raw) {
@@ -34,10 +34,11 @@ export function antigravityAdapter(executable, defaultTransport, options = {}) {
                 })
                 : [];
             const numTurns = typeof envelope.num_turns === 'number' ? envelope.num_turns : null;
+            const conversationId = typeof envelope.conversation_id === 'string' ? envelope.conversation_id : null;
             const result = {
                 success: false, response, error: null,
                 cliStatus: typeof envelope.status === 'string' ? envelope.status : null,
-                numTurns, deniedActions, stats: extractStats(envelope, null)
+                numTurns, deniedActions, stats: extractStats(envelope, null), conversationId
             };
             if (/print timeout|AGY_ERROR.*TIMEOUT/i.test(raw.stderr)) {
                 return { ...result, timeout: true, error: 'CLI reported a print timeout (possibly with exit code 0)' };

package/dist/src/agents/registry.js

@@ -22,6 +22,7 @@ export async function createAgentRegistry(config, antigravity) {
         id: 'antigravity', label: 'Antigravity', available: antigravityEnabled && antigravity.supported,
         version: antigravity.version || null, executable: antigravity.executable || null,
         capabilities: ['code', 'review', 'test', 'research', 'long-run'],
+        conversation_resume: antigravity.conversationResume,
         warnings: antigravityEnabled ? antigravity.warnings : ['Disabled in the bridge config']
     };
     agents.push({
@@ -110,6 +111,7 @@ export async function createAgentRegistry(config, antigravity) {
                     id: profileId, label, available: isProfileEnabled && supported,
                     version: version || null, executable: cmd || null,
                     capabilities: ['code', 'review', 'test', 'research', 'long-run'],
+                    conversation_resume: antigravity.conversationResume,
                     warnings: isProfileEnabled ? [...antigravity.warnings, ...profileWarnings] : profileWarnings
                 };
                 agents.push({

package/dist/src/antigravity/invocation.js

@@ -1,10 +1,12 @@
-export function invocationFor(prompt, timeout, transport, model = null, extraArgs = []) {
+/** `conversation` continues an earlier agy session (`--conversation <id>`), so it goes before `--print`: agy takes the prompt as the argument after it. */
+export function invocationFor(prompt, timeout, transport, model = null, extraArgs = [], conversation = null) {
+    const lead = conversation ? ['--conversation', conversation] : [];
     const common = ['--print-timeout', `${timeout}s`, '--disable-slash-commands', ...(model ? ['--model', model] : []), ...extraArgs];
     if (transport === 'argv')
-        return { args: ['--print', prompt, '--output-format', 'json', ...common], stdin: undefined };
+        return { args: [...lead, '--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' };
+        return { args: [...lead, '--print', prompt, '--output-format', 'stream-json', ...common], stdin: undefined };
+    return { args: [...lead, '--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/antigravity/process.js

@@ -170,6 +170,6 @@ export async function inspectCli(command, cwd, run = startProcess, requireStdin
         ['--print', '--output-format', '--print-timeout', '--disable-slash-commands', ...(requireStdin ? ['--input-format'] : [])].every(flag => new RegExp(`(?:^|\\s)${flag}(?=\\s|$)`).test(help.text));
     const verified = VERIFIED_AGY_VERSIONS.includes(actual);
     const warnings = supported && !verified ? [`agy ${actual} is compatible by 1.4.x version/help checks, but only ${VERIFIED_AGY_VERSIONS.join(' and ')} have been verified with real agent execution`] : [];
-    return { version: actual, supported, executable: command.executable, prefixArgs: command.prefixArgs, warnings };
+    return { version: actual, supported, executable: command.executable, prefixArgs: command.prefixArgs, warnings, conversationResume: /(?:^|\s)--conversation(?=\s|$)/.test(help.text) };
 }
 //# sourceMappingURL=process.js.map

package/dist/src/security/input.js

@@ -11,7 +11,9 @@ export const delegateSchema = z.object({
     agent: z.string().trim().min(1).max(64).optional(),
     isolation: z.enum(['none', 'worktree']).default('none'),
     owns: z.array(ownPath).max(100).default([]),
-    autonomy: z.enum(['suggest', 'auto', 'full']).optional()
+    autonomy: z.enum(['suggest', 'auto', 'full']).optional(),
+    /** Continue an Antigravity conversation the bridge itself ran, by the `conversation_id` in that task's output. */
+    resume_conversation: z.uuid().optional().describe('Continue an earlier Antigravity conversation instead of starting one: pass the conversation_id of a finished task in this same workspace. The bridge only accepts conversations it ran itself')
 }).strict().superRefine((input, ctx) => {
     if (input.isolation === 'worktree' && input.owns.length === 0) {
         ctx.addIssue({ code: 'custom', path: ['owns'], message: 'Worktree isolation requires at least one path in owns' });

package/dist/src/tasks/manager.js

@@ -118,7 +118,9 @@ export class TaskManager {
         return {
             agents: this.agents.map(({ adapter, status, enabled }) => ({
                 id: adapter.id, label: adapter.label, enabled, available: status.available, version: status.version,
-                executable: status.executable, capabilities: adapter.capabilities, warnings: status.warnings
+                executable: status.executable, capabilities: adapter.capabilities, warnings: status.warnings,
+                // A client only offers `resume_conversation` for an agent whose CLI was probed and shown to take `--conversation`.
+                conversation_resume: status.conversation_resume
             })),
             default_agent: this.defaultAgent,
             max_parallel_worktrees: this.maxParallelWorktrees
@@ -128,6 +130,13 @@ export class TaskManager {
     delegate(raw, meta = {}) {
         return this.admitInOrder(raw, meta);
     }
+    /** The task that ran this agy conversation, while it is still in the bridge's history (a restart reloads it from disk). */
+    conversationOwner(conversationId) {
+        for (const entry of this.entries.values())
+            if (entry.task.conversation_id === conversationId)
+                return entry.task;
+        return undefined;
+    }
     admitInOrder(raw, meta, rerun) {
         const admitted = this.admission.then(() => this.admit(raw, meta, rerun));
         this.admission = admitted.then(() => undefined, () => undefined);
@@ -158,6 +167,25 @@ export class TaskManager {
             }
         const supported = Boolean(agent?.status.available);
         const autonomy = input.autonomy ?? this.config.default_autonomy ?? 'auto';
+        // An agy conversation id is machine-global, so the bridge only continues one it ran itself and only in the workspace that
+        // created it: otherwise a client could aim a task at another project's context, or at the owner's own interactive session.
+        let resumeConversation = null;
+        if (input.resume_conversation !== undefined) {
+            if (agent?.adapter.family !== 'antigravity') {
+                throw new Error(`resume_conversation needs Antigravity, not agent "${agent?.adapter.id ?? input.agent ?? 'the default agent'}"`);
+            }
+            if (agent.status.conversation_resume === false) {
+                throw new Error(`The Antigravity CLI${agent.status.version ? ` ${agent.status.version}` : ''} has no --conversation, so no task can continue a conversation`);
+            }
+            const source = this.conversationOwner(input.resume_conversation);
+            if (!source) {
+                throw new Error(`resume_conversation "${input.resume_conversation}" is not a conversation this bridge ran. Read conversation_id from a finished task's output; a task the retention limit dropped can no longer be resumed`);
+            }
+            if (source.workspace !== workspace) {
+                throw new Error(`Conversation "${input.resume_conversation}" was created in another workspace, so it is not continued here`);
+            }
+            resumeConversation = input.resume_conversation;
+        }
         // Everything from here to the registration of the entry is synchronous, so concurrent callers cannot both claim a slot.
         // Ordinary tasks are serialized globally; worktree tasks may run in parallel up to max_parallel_worktrees.
         const queued = supported && !this.canStart(input.isolation);
@@ -183,6 +211,7 @@ export class TaskManager {
             stdout: '', stderr: '', stdout_bytes: 0, stderr_bytes: 0,
             stdout_truncated: false, stderr_truncated: false,
             final_response: null, cli_status: null, error: null, denied_actions: [], review_required: true, acceptance_verified: false,
+            conversation_id: resumeConversation,
             ...(rerun ? { retry_of: rerun.retryOf, elevation: rerun.elevation } : {})
         };
         const pools = this.config.agents?.pools ?? {};
@@ -197,7 +226,9 @@ export class TaskManager {
                 agent: task.agent, isolation: input.isolation, owns: input.owns, autonomy,
                 model: agent?.adapter.family === 'antigravity' ? await readModel(this.runtime.stateDirectory) : null,
                 permission: permissionState(this.runtime.stateDirectory).level,
-                effort: readEffort(this.runtime.stateDirectory)
+                effort: readEffort(this.runtime.stateDirectory),
+                // Only a task that continues a conversation carries the field, so the request of an ordinary task keeps its shape.
+                ...(resumeConversation ? { resume_conversation: resumeConversation } : {})
             }
         };
         this.entries.set(task.task_id, entry);
@@ -349,7 +380,9 @@ export class TaskManager {
                 autonomy, owns: task.owns, taskId: task.task_id, stateDirectory: this.runtime.stateDirectory,
                 // The task's model is a per-family setting: a codex model handed to another family would override that family's own.
                 model: antigravity ? entry.request?.model ?? null : agent.adapter.family === 'codex' ? this.config.agents?.codex_model : undefined,
-                extraArgs, promptTransport: transport, elevation
+                extraArgs, promptTransport: transport, elevation,
+                // Set when this task continues an earlier Antigravity conversation (validated when the task was admitted).
+                conversationId: task.conversation_id
             });
             if (invocation.resultFile)
                 await mkdir(path.dirname(invocation.resultFile), { recursive: true });
@@ -536,6 +569,9 @@ export class TaskManager {
                         if (result.stats)
                             entry.stats = { ...result.stats, steps: entry.steps?.total ?? null };
                         task.cli_status = result.cliStatus;
+                        // The CLI names the conversation it used, which is what a follow-up task hands back as resume_conversation.
+                        if (result.conversationId)
+                            task.conversation_id = result.conversationId;
                         task.final_response = result.response === null ? null : redact(result.response);
                         task.denied_actions = result.deniedActions.slice(0, 100).map(item => ({
                             action: redact(item.action).slice(0, 200), display_name: redact(item.display_name).slice(0, 200),

package/dist/src/tools/register.js

@@ -62,7 +62,7 @@ export function createServer(manager, environment, missions) {
         inputSchema: z.object({}).strict(), annotations: { readOnlyHint: true, openWorldHint: false }
     }, async () => response(manager.agentsOverview()));
     server.registerTool('antigravity_delegate', {
-        description: 'Start one supervised agent task. Pick agent (default from config), isolation "worktree" plus owns paths for parallel isolated work, and autonomy. Returns running with task_id; poll status/output. Completion always needs Tech Lead diff/test review. Never authorize destructive/system/deploy actions with this tool.',
+        description: 'Start one supervised agent task. Pick agent (default from config), isolation "worktree" plus owns paths for parallel isolated work, and autonomy. To correct a finished Antigravity task without re-explaining it, pass resume_conversation with that task\'s conversation_id. Returns running with task_id; poll status/output. Completion always needs Tech Lead diff/test review. Never authorize destructive/system/deploy actions with this tool.',
         inputSchema: delegateSchema, annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
     }, async (input, ctx) => guard(() => manager.delegate(input, { client: clientLabel(ctx.mcpReq.envelope) })));
     server.registerTool('antigravity_task_status', {
@@ -91,7 +91,7 @@ export function createServer(manager, environment, missions) {
         return withNextStep(manager.summary(task_id), manager.activityNote(task_id));
     }));
     server.registerTool('antigravity_task_output', {
-        description: 'Get final response, partial stdout/stderr logs, errors and truncation metadata. Does not wait for completion.',
+        description: 'Get final response, partial stdout/stderr logs, errors and truncation metadata. conversation_id names the Antigravity session a follow-up task can continue with resume_conversation. Does not wait for completion.',
         inputSchema: taskIdSchema, annotations: { readOnlyHint: true, openWorldHint: false }
     }, async ({ task_id }) => guard(() => manager.get(task_id)));
     server.registerTool('antigravity_cancel_task', {

package/docs/VERIFICATION.md

@@ -86,3 +86,17 @@ Unit/integration dùng mock nằm ở `tests/bridge.test.ts`, được tách kh
 - [Codex MCP](https://developers.openai.com/codex/mcp/): stdio command/args và timeouts. `codex mcp --help`, `codex mcp add --help` xác nhận CLI quản lý cấu hình hiện hành.
 
 Tài liệu headless ghi mặc định print-timeout 5m và workspace write tự cho phép; help 1.4.3 tại máy ghi 0s, và thử ghi thực tế bị từ chối. Bridge luôn truyền timeout rõ ràng và tôn trọng denial thực tế, không giả định theo mô tả chung.
+
+## Bổ sung 2026-11-06 — hội thoại Antigravity (`--conversation`)
+
+Máy thật, `agy` 1.4.12 (`%LOCALAPPDATA%\agy\bin\agy.exe`), tài khoản đang đăng nhập. Các con số dưới là JSON do chính CLI trả, không suy ra từ tài liệu.
+
+- Envelope in ra có `conversation_id`; phiên thứ hai với `--conversation <id>` trả về **cùng id** và `num_turns: 2`. CLI đọc hội thoại từ `~/.gemini/antigravity-cli/conversations/<id>.db`, tức **id này là toàn máy**, không gắn với một thư mục dự án.
+- Bridge dùng điều đó làm hai lớp chặn: `resume_conversation` chỉ nhận id mà chính bridge đã ghi trong lịch sử task, và chỉ trong **đúng workspace** đã tạo hội thoại đó. Không có hai chặn này, một client chọn id tùy ý sẽ nạp ngữ cảnh của dự án khác, hoặc của phiên tương tác của chủ máy, vào task.
+- Chi phí token đo bằng cờ của bridge (`--disable-slash-commands --mode auto`): lượt đầu 6.107 input / 12.223 cache-read; lượt tiếp theo của cùng hội thoại 8.394 input / 28.500 cache-read. `agy` gửi lại toàn bộ hội thoại làm input mỗi lượt — tiếp nối rẻ hơn viết lại ngữ cảnh, nhưng không miễn phí.
+- `--mode auto` in cảnh báo `not available for this account; continuing in the default mode` ở cả hai lượt; bridge không đổi hành vi vì cảnh báo này.
+- Probe `--help` quyết định `agents_list.conversation_resume`, và probe tại máy cho thấy cờ này **không phải thứ phân biệt các bản**: `agy` 1.4.3 (bảng help ghi ngày 2026-10-26, mục "Các tham số ... được công bố bởi help tại máy" ở phần trên) và `agy` 1.5.1 (đo lại 2026-11-06) đều liệt kê `--conversation`. Điều bridge từ chối resume vì help không có cờ do đó gần như không xảy ra trên 1.4.x; gate chủ yếu để chặn các bản CLI cũ hơn mà bridge chưa từng probe. Chưa chạy task resume thật trên 1.4.3 — bằng chứng execution chỉ có ở 1.4.12. Codex: điều đã đo là **phía bridge** — `src/agents/codex.ts` chỉ đọc các event `error`, `turn.completed`, `item.completed` từ `codex exec --json` và không lấy id nào, nên bridge ghi `null` và không hứa resume. Việc bản thân CLI Codex có tiếp tục được một phiên hay không **chưa đo ở đây**, và tài liệu này không khẳng định là không.
+- Bridge **không** dùng `-c` / `--continue` ("Continue the most recent conversation", có trong help 1.5.1): nó trỏ tới hội thoại mới nhất của toàn máy, kể cả phiên tương tác mà chính chủ máy đang dùng, nên một task headless có thể ghi đè ngữ cảnh đó. `--conversation <id>` cộng với hai lớp chặn ở trên là lựa chọn có chủ đích, không phải thiếu sót.
+- `--conversation` dùng chung với `--json-schema` vẫn chạy: cùng `conversation_id`, và CLI thêm trường `structured_output` chứa object đã_validate (trường `response` vẫn lẫn văn bản model tự viết, nên muốn tin thì phải đọc `structured_output`). Lượt đó mất 4 turn và 702 giây — bridge chưa dùng `--json-schema`, mục này chỉ ghi lại rằng hai cờ không xung đột.
+- Không đo: `agy_acp_server.par` (artifact Google có trên CDN cho Windows x64/arm64, bản 1.4.1). Đó là hướng thay đổi adapter, không thuộc phạm vi bổ sung này.
+- Đo lúc 2026-11-06 (sau khi các dòng trên đã ghi): `agy --version` trên máy này là **1.5.1** — CLI tự cập nhật, còn các số liệu token/help ở trên lấy khi nó là 1.4.12. Help 1.5.1 vẫn liệt kê đầy đủ mọi cờ mà probe yêu cầu (`--print`, `--output-format`, `--print-timeout`, `--disable-slash-commands`, `--input-format`, thêm cả `--conversation`, `--json-schema`, `--mode`, `--effort`, `--log-file`), nhưng `supported` ở `src/antigravity/process.ts` đòi `/^1\.4\.\d+$/`, nên bridge hiện đánh dấu Antigravity unavailable và **từ chối mọi delegation trên chính máy này**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-mcp-bridge",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Local loopback HTTP MCP bridge that delegates bounded coding tasks to multiple agent CLIs (Antigravity, Codex) with optional parallel git worktrees",
   "license": "MIT",
   "keywords": [

package/skills/antigravity-bridge/SKILL.md

@@ -93,6 +93,7 @@ For independent work that may run in parallel, isolate it in a git worktree and
 ```
 
 - `agent` and `autonomy` are optional. `isolation` defaults to `"none"`; `"worktree"` requires at least one `owns` entry, and `owns` is rejected with `"none"`.
+- Every Antigravity task reports `conversation_id`. By default each delegation still starts a new conversation, so keep writing the context the task needs. `resume_conversation` (that id, same workspace, Antigravity only) continues the earlier one instead: use it for a correction of the same work, and treat what it carries over as history, not as instructions. It costs no extra description, but it does not restore the earlier task's diff or permissions.
 - `owns` entries are relative paths inside the workspace. Absolute paths, drive paths, `.` and `..` segments are rejected. The bridge compares the final diff and reports `scope.out_of_scope`.
 - A worktree task runs on branch `bridge/<task_id>` and returns `worktree`/`branch`. The bridge never auto-merges it; the Tech Lead reviews and integrates.
 - `autonomy` (`suggest`/`auto`/`full`) only tells the CLI how much to ask within the declared scope. Deployment, data deletion, credential access, protected-branch pushes and system changes outside the workspace stay forbidden; never add bypass flags.
@@ -131,6 +132,6 @@ Client disconnect does not cancel an accepted task. Reconnect to the same runnin
 
 Compare current tracked and untracked files with the baseline; for a worktree task, compare inside `task.worktree` on `task.branch` instead. Inspect the actual code and any affected backend/API contracts. Run meaningful authorized checks yourself; distinguish mock/protocol tests from real CLI integration. Evaluate each acceptance criterion. The bridge always returns `review_required=true` and `acceptance_verified=false`; do not override this by trusting the Developer's report.
 
-If correction is needed, submit a new bounded task with the exact defect, relevant failure output, files to preserve, and updated criteria. Include prior findings as context; a previous task ID alone does not resume its CLI conversation. If progress requires a new architecture decision, broader permissions or destructive actions, stop that action for the user's decision while continuing independent review where possible.
+If correction is needed, submit a new bounded task with the exact defect, relevant failure output, files to preserve, and updated criteria. Include prior findings as context; a previous task ID alone does not resume its CLI conversation, but its `conversation_id` does, through `resume_conversation`. If progress requires a new architecture decision, broader permissions or destructive actions, stop that action for the user's decision while continuing independent review where possible.
 
 Report changed files, checks actually run and their results, unmet criteria and limitations. Never claim code was tested/deployed merely because the agent said so. Never delegate deployment, data deletion, system changes, commits or pushes through this bridge. Those actions require their own explicit authorized workflow.

package/skills/known-versions.json

@@ -69,6 +69,10 @@
       {
         "sha256": "d0f94ad3c993ffc7778b68309217704ef236d370a6ea1edbe360f92980af5984",
         "note": "profile and pool ids as agent, quota failover at-most-once, attempts[] evidence, code_search refusal"
+      },
+      {
+        "sha256": "006be28209670d2285ef243952643dade865f2ae063b149d9a5f73894f7d896e",
+        "note": "conversation_id and resume_conversation: a correction can continue the same Antigravity conversation"
       }
     ],
     "mission-orchestrator": [

package/ui/app.js

@@ -674,7 +674,8 @@ function detailView() {
       ['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 : '—'], ['Tổng token', state.detail?.stats?.usage && 'total_tokens' in state.detail.stats.usage ? number(state.detail.stats.usage.total_tokens) : '—'], ['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))));
+      ['CLI status', task.cli_status ?? '—'],
+      ['Hội thoại agy', task.conversation_id ? h('span', {class: 'mono', title: request?.resume_conversation ? 'Task này tiếp tục hội thoại của task trước, nên nó mang ngữ cảnh task trước để lại.' : 'Định danh hội thoại agy của task này.', text: `${task.conversation_id}${request?.resume_conversation ? ' (tiếp nối)' : ''}`}) : '—']].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';
   const asked = h('div', {class: 'msg out'},