agy-mcp-bridge 0.1.33 → 0.1.35

package/README.md

@@ -1,4 +1,4 @@
-# agy-mcp-bridge
+# agy-mcp-bridge.
 
 **An MCP server that hands bounded coding tasks to the CLI agents already logged in on your machine.** One TypeScript process speaks MCP Streamable HTTP on `127.0.0.1` and drives `agy` (Antigravity) and/or `codex`. Every task declares its workspace, acceptance criteria, which agent runs it, how isolated it is, and how much it may self-approve. The orchestrating agent (Codex, Claude Code, any MCP client) keeps the review; the bridge does the reading, writing and waiting.
 

package/dist/src/agents/codex.js

@@ -5,6 +5,9 @@ import { captureOutput } from './probe.js';
 const CAPABILITIES = ['code', 'review', 'test', 'research', 'long-run'];
 const REQUIRED_FLAGS = ['--json', '--sandbox', '--cd', '--output-last-message', '--ephemeral', '--skip-git-repo-check'];
 const MAX_RESULT_BYTES = 1024 * 1024;
+const MAX_DENIED = 20;
+/** Output a sandboxed Windows or POSIX shell prints when it is not allowed to write: "Access ... is denied", "Permission denied", "Read-only file system". */
+const SANDBOX_REFUSAL = /access\b[^\n]{0,200}\bdenied|permission denied|read-only file system|operation not permitted/i;
 export function codexAdapter(command, options = {}) {
     return {
         id: options.id ?? 'codex',
@@ -23,6 +26,9 @@ export function codexAdapter(command, options = {}) {
                 args.unshift('--ask-for-approval', options.askForApproval);
             if (options.model)
                 args.push('-m', options.model);
+            // One extra writable directory for this run, granted by the owner after a denial: `--add-dir` opens exactly the directory it names (measured on 0.163.0).
+            if (task.elevation?.kind === 'codex-add-dir')
+                args.push('--add-dir', task.elevation.dir);
             args.push('-');
             return { executable: command.executable, args, stdin: `${task.prompt}\n`, resultFile, customEnv: options.env };
         },
@@ -41,6 +47,7 @@ export function codexAdapter(command, options = {}) {
             const errors = [];
             const messages = [];
             const deniedActions = [];
+            let reported = 0;
             let turns = 0;
             let cliStatus = null;
             for (const event of events) {
@@ -56,6 +63,14 @@ export function codexAdapter(command, options = {}) {
                         messages.push(item.text);
                     if (typeof item.status === 'string' && ['declined', 'denied'].includes(item.status)) {
                         deniedActions.push({ action: 'command', display_name: String(item.command ?? item.type ?? 'declined action').slice(0, 200) });
+                        reported++;
+                    }
+                    // In `codex exec` a command the sandbox refuses is not "declined": it is a failed command whose output says so (measured on 0.163.0, no
+                    // approval event, `on-request` and `never` alike). That is only a guess from text, so it is marked and never fails the task.
+                    if (item.type === 'command_execution' && item.status === 'failed' && typeof item.aggregated_output === 'string' && SANDBOX_REFUSAL.test(item.aggregated_output) && deniedActions.length < MAX_DENIED) {
+                        const shown = String(item.command ?? 'command').slice(0, 200);
+                        if (!deniedActions.some(existing => existing.display_name === shown))
+                            deniedActions.push({ action: 'command', display_name: shown, suspected: true });
                     }
                 }
             }
@@ -70,7 +85,7 @@ export function codexAdapter(command, options = {}) {
             const response = lastMessage.trim() ? lastMessage : messages.at(-1) ?? null;
             const result = { success: false, response, error: null, cliStatus, numTurns: turns || null, deniedActions };
             // A denied action is a failure even when the CLI exits 0 with a final message.
-            if (deniedActions.length)
+            if (reported)
                 return { ...result, error: 'Codex reported a denied action; review the approval policy before retrying' };
             if (raw.exitCode === 0 && response?.trim())
                 return { ...result, success: true, numTurns: turns || 1 };

package/dist/src/agents/opencode.js

@@ -4,6 +4,46 @@ export const CAPABILITIES = ['code', 'review', 'test', 'research', 'long-run'];
 // Verified against opencode v2.2.5: `opencode run` reads the message from stdin and, with `--format json`, writes one JSON event per line.
 const REQUIRED_FLAGS = ['--format', '--model', '--auto', '--standalone'];
 const MAX_RESPONSE_CHARS = 1024 * 1024;
+const MAX_DENIED = 20;
+/** The error of a tool call that OpenCode refused because it could not ask (v2.2.5: "This non-interactive run cannot ask the user for permission, ..."). */
+const PERMISSION_REJECTED = /cannot ask the user for permission/i;
+/** What a refused tool call was asked to do, in a few words: the command of a shell call, the path of a file call, else the names of its arguments. */
+function summarizeToolInput(tool, input) {
+    if (typeof input === 'string')
+        return input.slice(0, 200);
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return '';
+    const value = input;
+    const pick = typeof value.command === 'string' ? value.command : typeof value.path === 'string' ? value.path : typeof value.filePath === 'string' ? value.filePath : null;
+    return (pick ?? Object.keys(value).slice(0, 5).join(', ')).slice(0, 200);
+}
+/**
+ * The OPENCODE_CONFIG_CONTENT of one run with `permission` set to allow for a single permission, keeping whatever else the profile already set.
+ * A value that is not a JSON object is refused rather than overwritten: this is a permission being widened, so it must be exactly what was meant.
+ */
+function withAllowedPermission(env, permission) {
+    let config = {};
+    const existing = env?.OPENCODE_CONFIG_CONTENT;
+    if (existing !== undefined) {
+        try {
+            const parsed = JSON.parse(existing);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('not an object');
+            config = parsed;
+        }
+        catch {
+            throw new Error('Cannot widen this run: the profile\'s OPENCODE_CONFIG_CONTENT is not a JSON object');
+        }
+    }
+    // A plain "allow" for everything already covers it; any other value is replaced for this one permission only.
+    if (config.permission === 'allow')
+        return { ...env };
+    // A single string such as "ask" applies to every permission; turning it into a per-permission object would silently loosen the others.
+    if (typeof config.permission === 'string')
+        throw new Error('Cannot widen this run: the profile sets one permission for everything, so a single permission cannot be opened on its own');
+    const current = config.permission && typeof config.permission === 'object' && !Array.isArray(config.permission) ? config.permission : {};
+    return { ...env, OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...config, permission: { ...current, [permission]: 'allow' } }) };
+}
 export function opencodeAdapter(command, options = {}) {
     return {
         id: options.id ?? 'opencode',
@@ -28,11 +68,17 @@ export function opencodeAdapter(command, options = {}) {
             // instruction to the agent, never a permission grant, so it must not reach a flag that takes approval away.
             if (options.autoApprove)
                 args.push('--auto');
+            // Permission the owner granted this one run after a denial. It reaches OpenCode only through this run's arguments and environment.
+            let env = options.env;
+            if (task.elevation?.kind === 'opencode-auto')
+                args.push('--auto');
+            else if (task.elevation?.kind === 'opencode-allow')
+                env = withAllowedPermission(env, task.elevation.permission);
             return {
                 executable: command.executable,
                 args: [...command.prefixArgs, ...args],
                 stdin: `${task.prompt}\n`,
-                customEnv: options.env
+                customEnv: env
             };
         },
         compactLine(line) {
@@ -52,8 +98,14 @@ export function opencodeAdapter(command, options = {}) {
             if (type === 'step_start')
                 return null;
             // A tool event carries the file or command output it produced: keep which tool ran and how it ended, not the payload.
-            if (type === 'tool_use')
-                return JSON.stringify({ type, part: { tool: part?.tool, state: { status: part?.state?.status } } });
+            // A tool that failed also keeps its error text and a short note of what it was asked to do: that is how a refused permission is recognized.
+            if (type === 'tool_use') {
+                const state = part?.state;
+                const failed = state?.status === 'error';
+                return JSON.stringify({ type, part: { tool: part?.tool, state: {
+                            status: state?.status, ...(failed ? { error: String(state?.error ?? '').slice(0, 300), input: summarizeToolInput(part?.tool, state?.input) } : {})
+                        } } });
+            }
             return line.length > 2000 ? JSON.stringify({ type }) : line;
         },
         async parseResult(raw) {
@@ -64,6 +116,7 @@ export function opencodeAdapter(command, options = {}) {
             let inputTokens = 0;
             let outputTokens = 0;
             let sawTokens = false;
+            const denied = [];
             for (const line of raw.stdout.split(/\r?\n/)) {
                 if (!line.trim())
                     continue;
@@ -80,6 +133,16 @@ export function opencodeAdapter(command, options = {}) {
                 const part = event.part;
                 if (event.type === 'text' && typeof part?.text === 'string')
                     texts.push(part.text);
+                else if (event.type === 'tool_use') {
+                    // `permission` set to ask makes a non-interactive run reject the request on the spot and carry on (measured on v2.2.5).
+                    const state = part?.state;
+                    if (state?.status === 'error' && PERMISSION_REJECTED.test(String(state.error ?? '')) && denied.length < MAX_DENIED) {
+                        const tool = String(part?.tool ?? 'tool').slice(0, 60);
+                        const note = summarizeToolInput(part?.tool, state.input);
+                        if (!denied.some(item => item.action === tool && item.display_name === (note ? `${tool}: ${note}` : tool)))
+                            denied.push({ action: tool, display_name: note ? `${tool}: ${note}` : tool });
+                    }
+                }
                 else if (event.type === 'error') {
                     const error = event.error;
                     errors.push(typeof error?.message === 'string' ? error.message : typeof error?.type === 'string' ? error.type : 'OpenCode reported an error');
@@ -102,7 +165,7 @@ export function opencodeAdapter(command, options = {}) {
             // The last text event is the final answer; earlier ones are narration between tool calls.
             const response = texts.at(-1)?.slice(0, MAX_RESPONSE_CHARS).trim() || null;
             const base = {
-                success: false, response, error: null, cliStatus: finishReason, numTurns: turns || null, deniedActions: [],
+                success: false, response, error: null, cliStatus: finishReason, numTurns: turns || null, deniedActions: denied,
                 stats: sawTokens ? { usage: { input_tokens: inputTokens, output_tokens: outputTokens }, agy_duration_seconds: null, num_turns: turns || null, steps: turns || null } : undefined
             };
             if (raw.exitCode === 0 && !errors.length && response)

package/dist/src/approvals.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { z } from 'zod';
+/**
+ * The owner's approval queue (docs/APPROVAL-QUEUE-PLAN.md): a task that ended with actions its agent was refused can be run again, as a new task,
+ * with a little more permission for that one run, or be dismissed. No CLI the bridge drives lets a person approve in the middle of a run, so
+ * this is approval afterwards. Nothing here widens a setting: the permission granted is an Elevation stored on the new task and applied to its
+ * own launch only, and the only way to create one is the owner's confirmed request in the web UI (there is no MCP tool for it).
+ */
+/** Strict on purpose: an unknown kind or field is refused, not ignored. */
+export const elevationSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('agy-level'), level: z.enum(['accept-edits', 'auto', 'full']) }).strict(),
+    z.object({ kind: z.literal('codex-add-dir'), dir: z.string().min(1).max(4096) }).strict(),
+    z.object({ kind: z.literal('opencode-allow'), permission: z.enum(['bash', 'edit']) }).strict(),
+    z.object({ kind: z.literal('opencode-auto') }).strict()
+]);
+export function parseElevation(value) {
+    const parsed = elevationSchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error('elevation is not one of the permissions this agent can be given');
+    return parsed.data;
+}
+/** OpenCode names the tool (`shell`, `write`, ...), its permission config names the permission (`bash`, `edit`). */
+const OPENCODE_PERMISSION = { shell: 'bash', bash: 'bash', write: 'edit', edit: 'edit', patch: 'edit', multiedit: 'edit' };
+export function opencodePermissionsOf(denied) {
+    return [...new Set(denied.flatMap(item => OPENCODE_PERMISSION[item.action.toLowerCase()] ?? []))];
+}
+/** What the owner may pick for a task of this agent family that was refused these actions. Empty when there is no narrow way (the queue then only dismisses). */
+export function elevationOptions(family, denied) {
+    if (!denied.length)
+        return [];
+    if (family === 'antigravity') {
+        return [
+            { kind: 'agy-level', elevation: { kind: 'agy-level', level: 'accept-edits' }, needs_dir: false, narrowest: true, wide: false },
+            { kind: 'agy-level', elevation: { kind: 'agy-level', level: 'auto' }, needs_dir: false, narrowest: false, wide: false },
+            { kind: 'agy-level', elevation: { kind: 'agy-level', level: 'full' }, needs_dir: false, narrowest: false, wide: true }
+        ];
+    }
+    if (family === 'codex')
+        return [{ kind: 'codex-add-dir', elevation: null, needs_dir: true, narrowest: true, wide: false }];
+    const allowed = opencodePermissionsOf(denied);
+    return [
+        ...allowed.map((permission) => ({ kind: 'opencode-allow', elevation: { kind: 'opencode-allow', permission }, needs_dir: false, narrowest: true, wide: false })),
+        { kind: 'opencode-auto', elevation: { kind: 'opencode-auto' }, needs_dir: false, narrowest: false, wide: true }
+    ];
+}
+/** Why an elevation may not be given to this task, or null when it may. The directory itself is checked on disk by the caller. */
+export function elevationRefusal(family, denied, elevation) {
+    const offered = elevationOptions(family, denied);
+    if (!offered.some(option => option.kind === elevation.kind))
+        return `This agent cannot be given "${elevation.kind}"`;
+    if (elevation.kind === 'agy-level')
+        return null;
+    if (elevation.kind === 'opencode-auto')
+        return null;
+    if (elevation.kind === 'opencode-allow')
+        return opencodePermissionsOf(denied).includes(elevation.permission) ? null : `The task was not refused "${elevation.permission}"`;
+    const dir = elevation.dir;
+    if (dir.includes('\0') || !path.isAbsolute(dir))
+        return 'The directory must be an absolute path';
+    if (path.parse(path.resolve(dir)).root === path.resolve(dir))
+        return 'A drive or filesystem root cannot be opened to an agent';
+    return null;
+}
+/** The agent family an elevation belongs to: one given for codex must never reach an opencode launch, and the other way round. */
+export const elevationFamily = (elevation) => elevation.kind === 'agy-level' ? 'antigravity' : elevation.kind === 'codex-add-dir' ? 'codex' : 'opencode';
+/** One line for the decision log and the page: what was granted, in the CLI's own terms. */
+export function describeElevation(elevation) {
+    switch (elevation.kind) {
+        case 'agy-level': return elevation.level === 'full' ? 'antigravity --dangerously-skip-permissions' : `antigravity --mode ${elevation.level}`;
+        case 'codex-add-dir': return `codex --add-dir ${elevation.dir}`;
+        case 'opencode-allow': return `opencode permission ${elevation.permission}=allow`;
+        case 'opencode-auto': return 'opencode --auto';
+    }
+}
+/** Waiting for the owner: finished, refused something, and not yet rerun or dismissed. */
+export function isPendingApproval(task) {
+    return task.denied_actions.length > 0 && task.status !== 'queued' && task.status !== 'running' && !task.approval;
+}
+//# sourceMappingURL=approvals.js.map

package/dist/src/decisions.js

@@ -7,6 +7,7 @@ import path from 'node:path';
 export const DECISIONS_FILE = 'decisions.jsonl';
 const MAX_FILE_BYTES = 512 * 1024;
 const KEEP_RECORDS = 500;
+const ACTIONS = ['apply', 'discard', 'approve', 'rerun', 'dismiss'];
 export async function appendDecision(stateDirectory, decision) {
     const file = path.join(stateDirectory, DECISIONS_FILE);
     try {
@@ -34,7 +35,7 @@ export async function readDecisions(stateDirectory, limit = 50) {
             continue;
         try {
             const value = JSON.parse(line);
-            if (typeof value.at === 'string' && typeof value.task_id === 'string' && (value.action === 'apply' || value.action === 'discard') && typeof value.ok === 'boolean') {
+            if (typeof value.at === 'string' && typeof value.task_id === 'string' && ACTIONS.includes(value.action) && typeof value.ok === 'boolean') {
                 records.push({ at: value.at, task_id: value.task_id, action: value.action, ok: value.ok, detail: String(value.detail ?? '').slice(0, 500) });
             }
         }

package/dist/src/tasks/manager.js

@@ -1,5 +1,5 @@
 import { existsSync, statSync } from 'node:fs';
-import { mkdir, readdir, readFile, realpath, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, realpath, rename, rmdir, stat, unlink, writeFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { StringDecoder } from 'node:string_decoder';
 import path from 'node:path';
@@ -12,6 +12,7 @@ import { redact } from '../security/redact.js';
 import { delegationState } from '../delegation.js';
 import { startProcess, terminateOwned } from '../antigravity/process.js';
 import { legacyAntigravityAgent } from '../agents/antigravity.js';
+import { describeElevation, elevationFamily, elevationOptions, elevationRefusal, isPendingApproval, parseElevation } from '../approvals.js';
 import { createWorktree, inspectScope, removeWorktree } from '../isolation/worktree.js';
 import { reapOwnedTree } from '../isolation/orphans.js';
 import { appendUsage, totalTokens } from '../usage.js';
@@ -125,11 +126,14 @@ export class TaskManager {
     }
     /** Calls are admitted strictly in the order they arrive: workspace validation is asynchronous and must not let a later call overtake an earlier one. */
     delegate(raw, meta = {}) {
-        const admitted = this.admission.then(() => this.admit(raw, meta));
+        return this.admitInOrder(raw, meta);
+    }
+    admitInOrder(raw, meta, rerun) {
+        const admitted = this.admission.then(() => this.admit(raw, meta, rerun));
         this.admission = admitted.then(() => undefined, () => undefined);
         return admitted;
     }
-    async admit(raw, meta) {
+    async admit(raw, meta, rerun) {
         if (this.closing)
             throw new Error('Bridge is shutting down');
         const delegation = delegationState(this.runtime.stateDirectory);
@@ -178,7 +182,8 @@ export class TaskManager {
             exit_code: null, signal: null,
             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
+            final_response: null, cli_status: null, error: null, denied_actions: [], review_required: true, acceptance_verified: false,
+            ...(rerun ? { retry_of: rerun.retryOf, elevation: rerun.elevation } : {})
         };
         const pools = this.config.agents?.pools ?? {};
         const poolId = (input.agent && pools[input.agent]) ? input.agent : (!input.agent && this.defaultAgent && pools[this.defaultAgent] ? this.defaultAgent : undefined);
@@ -314,7 +319,11 @@ export class TaskManager {
                 }
             }
             // The level in force when the task was accepted, or the current one if the owner has lowered it since: lowering applies to queued tasks too, raising never does.
-            const permission = lowerLevel(entry.request?.permission ?? 'default', permissionState(this.runtime.stateDirectory).level);
+            // A run the owner elevated from the approval queue uses the level they chose for it instead: that is the point of the grant, and it ends with this run.
+            const elevation = task.elevation ?? undefined;
+            if (elevation && agent.adapter.family !== elevationFamily(elevation))
+                throw new Error('The permission granted to this run does not belong to its agent');
+            const permission = elevation?.kind === 'agy-level' ? elevation.level : lowerLevel(entry.request?.permission ?? 'default', permissionState(this.runtime.stateDirectory).level);
             if (entry.request)
                 entry.request.permission = permission;
             // Soft deadline (owner setting, off by default): agy gets the absolute limit as its own print timeout and a log file whose growth shows it is alive.
@@ -340,7 +349,7 @@ 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
+                extraArgs, promptTransport: transport, elevation
             });
             if (invocation.resultFile)
                 await mkdir(path.dirname(invocation.resultFile), { recursive: true });
@@ -529,7 +538,8 @@ export class TaskManager {
                         task.cli_status = result.cliStatus;
                         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)
+                            action: redact(item.action).slice(0, 200), display_name: redact(item.display_name).slice(0, 200),
+                            ...(item.suspected ? { suspected: true } : {})
                         }));
                         if (result.timeout) {
                             finalStatus = 'timeout';
@@ -833,6 +843,97 @@ export class TaskManager {
             return this.summary(id);
         });
     }
+    /**
+     * The approval queue (docs/APPROVAL-QUEUE-PLAN.md). A task whose agent was refused something waits here; the owner, and only the owner, at the page,
+     * either runs it again as a NEW task with a little more permission for that one run, or sets the refusal aside. Both go through the same one-at-a-time
+     * queue as apply and discard, so a double click cannot start two reruns.
+     */
+    familyOf(agentId) { return this.agents.find(item => item.adapter.id === agentId)?.adapter.family ?? null; }
+    approvals() {
+        const views = [];
+        for (const [id, entry] of this.entries) {
+            const task = entry.task;
+            if (!task.denied_actions.length || task.status === 'queued' || task.status === 'running')
+                continue;
+            const family = this.familyOf(task.agent);
+            views.push({
+                task_id: id, agent: task.agent, family, status: task.status, ended_at: task.ended_at, workspace: task.workspace, isolation: task.isolation,
+                title: entry.request?.task.split('\n').find(line => line.trim())?.trim().slice(0, 140) ?? null,
+                denied: task.denied_actions.map(item => ({ ...item })), options: family ? elevationOptions(family, task.denied_actions) : [],
+                state: task.approval?.state ?? 'pending', rerun_task_id: task.approval?.task_id ?? null, retry_of: task.retry_of ?? null
+            });
+        }
+        return views.sort((a, b) => Date.parse(b.ended_at ?? '') - Date.parse(a.ended_at ?? '')).slice(0, 100);
+    }
+    approveTask(id, requested) {
+        return this.enqueueDecision(async () => {
+            const entry = this.entries.get(id);
+            if (!entry)
+                throw new Error('Unknown or expired task_id');
+            const original = entry.task;
+            if (original.approval)
+                throw new Error(original.approval.state === 'rerun' ? 'This task was already run again' : 'This task was already dismissed');
+            if (!isPendingApproval(original))
+                throw new Error(original.status === 'queued' || original.status === 'running' ? 'The task is still running' : 'This task has no refused actions waiting for approval');
+            const refuse = async (reason) => { await this.recordDecision(id, 'approve', false, reason); throw new Error(reason); };
+            const request = entry.request;
+            if (!request)
+                return refuse('The recorded request of this task is gone, so it cannot be run again');
+            const family = this.familyOf(original.agent);
+            if (!family)
+                return refuse(`Agent "${original.agent}" is no longer configured`);
+            let elevation;
+            try {
+                elevation = parseElevation(requested);
+            }
+            catch (error) {
+                return refuse(error instanceof Error ? error.message : 'Invalid permission');
+            }
+            const why = elevationRefusal(family, original.denied_actions, elevation);
+            if (why)
+                return refuse(why);
+            if (elevation.kind === 'codex-add-dir') {
+                const info = await stat(elevation.dir).catch(() => null);
+                if (!info?.isDirectory())
+                    return refuse('The directory does not exist');
+            }
+            // The new task is built from the request as it was recorded, never from anything the agent wrote.
+            const raw = {
+                task: request.task, workspace: original.workspace, acceptance_criteria: request.acceptance_criteria,
+                ...(request.context ? { context: request.context } : {}), timeout_seconds: request.timeout_seconds,
+                agent: request.agent ?? original.agent, isolation: request.isolation ?? original.isolation,
+                owns: request.owns ?? original.owns, autonomy: request.autonomy ?? original.autonomy
+            };
+            let created;
+            try {
+                created = await this.admitInOrder(raw, { client: request.client ?? null }, { retryOf: id, elevation });
+            }
+            catch (error) {
+                return refuse(`The new run could not be started: ${error instanceof Error ? redact(error.message) : 'unknown error'}`);
+            }
+            original.approval = { state: 'rerun', at: new Date().toISOString(), task_id: created.task_id };
+            await this.persist(original);
+            await this.recordDecision(id, 'approve', true, describeElevation(elevation));
+            await this.recordDecision(id, 'rerun', true, `task ${created.task_id}`);
+            return { task: created, rerun_of: id };
+        });
+    }
+    dismissApproval(id) {
+        return this.enqueueDecision(async () => {
+            const entry = this.entries.get(id);
+            if (!entry)
+                throw new Error('Unknown or expired task_id');
+            const task = entry.task;
+            if (task.approval)
+                throw new Error(task.approval.state === 'rerun' ? 'This task was already run again' : 'This task was already dismissed');
+            if (!isPendingApproval(task))
+                throw new Error(task.status === 'queued' || task.status === 'running' ? 'The task is still running' : 'This task has no refused actions waiting for approval');
+            task.approval = { state: 'dismissed', at: new Date().toISOString() };
+            await this.persist(task);
+            await this.recordDecision(id, 'dismiss', true, `${task.denied_actions.length} refused action(s) set aside`);
+            return this.summary(id);
+        });
+    }
     get(id) {
         const entry = this.entries.get(id);
         if (!entry)

package/dist/src/ui/review-routes.js

@@ -0,0 +1,53 @@
+/**
+ * The owner's approval queue over HTTP (docs/APPROVAL-QUEUE-PLAN.md). Only the web UI can reach it: there is deliberately no MCP tool to read the
+ * queue, approve, or raise a permission, so an agent or a client cannot approve what its own run was refused. Every change needs `confirm: true`.
+ */
+const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+function json(res, code, value) {
+    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer' });
+    res.end(JSON.stringify(value));
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 4096)
+            throw new Error('Request body too large');
+        chunks.push(chunk);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('Expected a JSON object');
+    return value;
+}
+/** Returns true when it answered the request. Errors are thrown to the caller, which turns them into a 400 (404 for an unknown task). */
+export async function handleReviewRoutes(req, res, ctx, pathname, method) {
+    if (pathname === '/ui/api/approvals' && method === 'GET') {
+        json(res, 200, { approvals: ctx.manager.approvals() });
+        return true;
+    }
+    const approve = pathname.match(new RegExp(`^/ui/api/tasks/(${UUID})/approve$`));
+    if (approve && method === 'POST') {
+        const body = await readJson(req);
+        if (body.confirm !== true) {
+            json(res, 400, { error: 'confirm must be true' });
+            return true;
+        }
+        const result = await ctx.manager.approveTask(approve[1], body.elevation);
+        json(res, 200, { rerun_of: result.rerun_of, task: ctx.manager.summary(result.task.task_id) });
+        return true;
+    }
+    const dismiss = pathname.match(new RegExp(`^/ui/api/tasks/(${UUID})/dismiss$`));
+    if (dismiss && method === 'POST') {
+        const body = await readJson(req);
+        if (body.confirm !== true) {
+            json(res, 400, { error: 'confirm must be true' });
+            return true;
+        }
+        json(res, 200, { task: await ctx.manager.dismissApproval(dismiss[1]) });
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=review-routes.js.map

package/dist/src/ui/routes.js

@@ -16,6 +16,7 @@ import { MAX_ABSOLUTE_LIMIT_SECONDS, MIN_ABSOLUTE_LIMIT_SECONDS, isAbsoluteLimit
 import { MAX_SETTING_WAIT_SECONDS, MIN_WAIT_SECONDS, clientToolTimeoutSeconds, isWaitSeconds, writeWait } from '../wait-setting.js';
 import { PERMISSION_LEVELS, isPermissionLevel, needsAcknowledgement, permissionState, writePermission } from '../permissions.js';
 import { inside } from '../security/workspace.js';
+import { handleReviewRoutes } from './review-routes.js';
 const assets = {
     '/ui': { file: 'index.html', type: 'text/html; charset=utf-8' },
     '/ui/': { file: 'index.html', type: 'text/html; charset=utf-8' },
@@ -163,6 +164,8 @@ export async function handleUi(req, res, ctx) {
             json(res, 200, await budgetState(ctx.manager.stateDirectory, tzOffset));
             return true;
         }
+        if (await handleReviewRoutes(req, res, ctx, pathname, method))
+            return true;
         const detail = pathname.match(new RegExp(`^/ui/api/tasks/(${UUID})$`));
         if (detail && method === 'GET') {
             json(res, 200, ctx.manager.detail(detail[1]));

package/docs/APPROVAL-QUEUE-PLAN.md

@@ -1,6 +1,6 @@
 # Hàng đợi duyệt cho hành động ngoài chính sách (Phase 4) — điều tra và thiết kế
 
-**Trạng thái:** B1, chỉ tài liệu. Chưa có mã hàng đợi. Phần cài đặt (B2) chỉ bắt đầu khi chủ dự án đồng ý thiết kế ở mục 5–6 và trả lời các câu hỏi ở mục 8.
+**Trạng thái:** B2 đã cài đặt theo thiết kế "duyệt sau" sau khi chủ dự án duyệt; những chỗ khác thiết kế và bằng chứng kiểm thật nằm ở mục 9. Các mục 1–8 là điều tra và thiết kế gốc, giữ nguyên.
 
 `docs/MULTI-AGENT-PLAN.md` (Phase 4) ghi "hàng đợi duyệt cho hành động ngoài chính sách". Điều chưa ai biết là **agent có dừng lại chờ duyệt giữa chừng được không**. Tài liệu này đo điều đó trên máy thật, rồi thiết kế đúng theo những gì đo được.
 
@@ -159,3 +159,42 @@ Ngoài MVP và chưa kiểm: duyệt giữa chừng (API server của OpenCode c
 4. **Codex "nghi ngờ"** (suy ra từ văn bản): có đưa vào hàng đợi (gắn nhãn suy đoán), hay chỉ làm khi CLI báo `declined`/`denied` thật?
 5. **`agy`**: đăng nhập `agy` trên máy này để đo mục 2.1 trước khi viết mã, hay chấp nhận thiết kế dựa trên bằng chứng cũ và cờ trong `--help`?
 6. Có làm việc ngoài phạm vi ở mục 7 (đặc biệt mục 1, thiếu nhận diện hết hạn mức OpenCode) thành PR riêng không?
+
+## 9. Đã cài đặt (B2): khác với thiết kế ở trên, và kiểm thật
+
+**Chốt cho các câu hỏi ở mục 8** (chủ dự án duyệt thiết kế, các câu hỏi còn lại lấy phương án đề xuất): (1) "duyệt sau" là MVP; (2) task worktree chạy lại dùng
+**worktree mới từ HEAD** (tự nhiên có được vì lần chạy lại là một task mới), worktree cũ giữ nguyên; (3) task có `denied_actions` ở OpenCode/Codex **giữ nguyên
+trạng thái** (`completed` kèm hành động bị từ chối) để không đổi hành vi mission và failover; (4) codex "nghi ngờ" **có** vào hàng đợi, gắn `suspected: true` và chỉ
+là suy đoán; (5) `agy` chưa đo lại (vẫn chưa đăng nhập): thiết kế dựa trên bằng chứng cũ và `--help`; (6) các quan sát ở mục 7 chưa sửa trong PR này.
+
+**Khác với mục 5:**
+
+- Trạng thái "đã chạy lại / đã bỏ qua" nằm **trên bản ghi task** (`approval: {state, at, task_id}`), không suy từ `decisions.jsonl` như mục 5.5 đã viết: nhật ký bị cắt
+  khi dài, bản ghi task thì không, và hàng đợi còn nguyên sau khi khởi động lại bridge (đã thử).
+- `dismiss` là một giá trị mới của `DecisionAction` (cùng `approve` và `rerun`).
+- `codex --sandbox danger-full-access` **không** được cài đặt: chưa đo, và là mức không có sandbox. Với codex chỉ có `--add-dir <thư mục>`; hành động không phải ghi
+  ngoài workspace (lệnh, mạng) thì hàng đợi chỉ cho bỏ qua.
+- Quyền nâng không vượt qua họ agent: một `Elevation` của codex không bao giờ tới lần launch của opencode và ngược lại (kiểm lúc duyệt và lúc launch).
+- OpenCode: một quyền cho từng lần chạy là bản vá `permission` trong `OPENCODE_CONFIG_CONTENT` của đúng lần launch đó, gộp vào cấu hình profile đã có; nếu profile đặt **một chuỗi
+  cho mọi quyền** (ví dụ `"permission": "ask"`) thì từ chối thay vì làm lỏng các quyền khác.
+
+**Kiểm thật trên giao diện** (bridge cô lập: `BRIDGE_HOME` và `ANTIGRAVITY_BRIDGE_CONFIG` tạm, cổng 3999, repo scratch; `opencode` 2.2.5 thật, model free; profile `oc-ask` có
+`permission: {bash: ask, edit: ask}` trong `OPENCODE_CONFIG_CONTENT`):
+
+1. Giao một task qua MCP (`antigravity_delegate`, agent `oc-ask`): OpenCode bị từ chối lệnh shell; task có `denied_actions` =
+   `shell: cd …\ws && echo IN_OK > inside.txt` (đọc từ sự kiện `tool_use` thật). Thanh bên hiện huy hiệu **1** ở mục "Duyệt".
+2. Khởi động lại bridge trên cùng thư mục: hàng đợi **còn nguyên** (yêu cầu vẫn "chờ duyệt").
+3. Ở trang Duyệt chọn "Cho phép chạy lệnh shell" (mức hẹp nhất, được chọn sẵn; `--auto` hiện nhãn "rộng") và bấm "Cho phép và chạy lại". Hộp thoại xác nhận ghi rõ
+   quyền, phạm vi và rằng chỉ cho một lần chạy.
+4. Task mới có `retry_of` và `elevation: {kind: "opencode-allow", permission: "bash"}`; task cũ thành `approval.state = "rerun"`; nhật ký có `approve` rồi `rerun`.
+   **`inside.txt` chứa `IN_OK` được tạo trong workspace** và lần chạy lại **không bị từ chối** (`denied_actions` rỗng) dù profile vẫn đặt `bash: ask`. Trang task của lần chạy
+   lại hiện ghi chú "lần chạy lại của task …". Trang Duyệt chuyển yêu cầu sang "Đã xử lý" kèm liên kết tới task mới.
+
+Điều kiểm thật tìm ra: một `null` trong mảng trả về của trang Duyệt hiện thành chữ "null" ở cuối trang (`replaceChildren` biến `null` thành văn bản); đã sửa.
+
+**Hạn chế đã thấy khi kiểm thật (chưa xử lý):**
+
+- Một run kết thúc vì **hết giờ hoặc bị hủy** không đọc kết quả của CLI (`parseResult` bị bỏ qua), nên các lần từ chối trong run đó **không** vào hàng đợi. OpenCode, khi bị từ chối, hay
+  thử cách khác cho tới khi hết giờ (đã thấy: model tiếp tục dùng tool `execute` của MCP); chỉ dẫn "bị từ chối thì dừng và báo" trong prompt làm run kết thúc đúng lúc.
+- Hạn mức miễn phí của OpenCode làm run dừng giữa chừng (`provider.free-limit`); lần từ chối trước đó vẫn được ghi lại, nhưng task `failed` vì lý do khác.
+- Chưa đo: bản vá `permission` qua `OPENCODE_CONFIG_CONTENT` thắng cấu hình **toàn cục** của người dùng (chỉ thấy nó thắng cấu hình `ask` của chính profile); `agy` ở mọi khía cạnh; Linux, macOS.

package/docs/MULTI-AGENT-PLAN.md

@@ -252,8 +252,12 @@ ngân sách token theo mission — usage vẫn chỉ được ghi và tổng h
 - Chỉ chủ bridge làm được việc này qua web UI (`POST /ui/api/tasks/<id>/apply|discard` với `confirm: true`). Không có tool MCP tương ứng, nên một
   agent hay client không tự áp dụng kết quả của chính nó.
 
-Chưa làm của Phase 4: trang Settings cho agent ưu tiên / số task song song / autonomy mặc định (hiện là file cấu hình), hàng đợi duyệt hành động
-ngoài chính sách và nút hợp nhất theo nhánh (commit).
+**Đã làm (lát cắt 3: hàng đợi duyệt hành động bị từ chối).** Trang "Duyệt" và panel trên trang Task (`docs/APPROVAL-QUEUE-PLAN.md`). Không CLI nào cho duyệt giữa chừng, nên đây là
+duyệt sau: task kết thúc mà agent bị từ chối hành động thì vào hàng đợi; chủ bridge chọn "Cho phép và chạy lại" (task mới có `retry_of`, kèm quyền hẹp nhất cho đúng lần đó:
+`agy --mode`, `codex --add-dir`, hoặc bản vá `permission` của `opencode`) hoặc "Bỏ qua". Quyền nâng không ghi vào cài đặt nào, không sang agent khác, và chỉ qua web UI
+(`GET /ui/api/approvals`, `POST /ui/api/tasks/<id>/approve|dismiss` với `confirm: true`); không có tool MCP nào để duyệt.
+
+Chưa làm của Phase 4: trang Settings cho agent ưu tiên / số task song song / autonomy mặc định (hiện là file cấu hình) và nút hợp nhất theo nhánh (commit).
 
 ### Phase 5 — Tích hợp và hardening
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-mcp-bridge",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "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/ui/app.css

@@ -245,3 +245,15 @@ pre.log { margin: 0; padding: 12px; border-radius: 10px; background: #0b0e14; co
 .usage-table th { font-weight: 600; color: var(--muted); }
 
 .over-budget { color: var(--bad); font-weight: 600; }
+
+/* Approval queue */
+.approvals-page { display: grid; gap: 16px; }
+.section-title { margin: 8px 0 0; font-size: 15px; }
+.approval-body { display: grid; gap: 12px; margin-top: 12px; }
+.option-list { display: grid; gap: 8px; }
+.option { display: flex; gap: 10px; align-items: flex-start; padding: 10px 12px; border: 1px solid var(--border); border-radius: 10px; cursor: pointer; }
+.option.picked { border-color: var(--accent); background: var(--accent-soft); }
+.option > span { display: grid; gap: 2px; }
+.chip.suspected { border-style: dashed; color: var(--muted); }
+.nav-badge { margin-left: auto; min-width: 20px; padding: 0 6px; border-radius: 999px; background: var(--bad); color: #fff; font-size: 12px; font-weight: 700; text-align: center; }
+.nav-badge[hidden] { display: none; }

package/ui/app.js

@@ -9,6 +9,7 @@ const ICONS = {
   missions: 'M4 5h4v4H4zM4 15h4v4H4zM16 10h4v4h-4zM8 7h3a2 2 0 0 1 2 2v3M8 17h3a2 2 0 0 0 2-2v-3',
   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',
+  approvals: 'M9 12l2 2 4-4M12 3l7 3v5c0 5-3.5 8-7 10-3.5-2-7-5-7-10V6z',
   out: 'M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9'
 };
 
@@ -20,6 +21,7 @@ const MATCH = {
 const state = {
   overview: null, selected: null, detail: null, view: 'tasks', logTab: 'stdout',
   missions: null, selectedMission: null, plan: null,
+  approvals: null, approvalPick: {}, approvalDir: {},
   open: new Set(), changes: null, connected: true, toast: '', q: '', filter: 'all'
 };
 let timer = null;
@@ -176,6 +178,129 @@ function followChanges() {
   if (state.changes?.task_id !== task.task_id || state.changes.loading) return;
   void loadChanges(task.task_id, true);
 }
+/* ---------- Approval queue: a task whose agent was refused something waits here. No CLI lets the owner approve in the middle of a run, so the owner either
+   runs the task again, as a new task, with a little more permission for that one run, or sets the refusal aside. Only this page can do it. ---------- */
+const DECISION_LABEL = {apply: 'Áp dụng', discard: 'Bỏ worktree', approve: 'Cho phép', rerun: 'Chạy lại', dismiss: 'Bỏ qua'};
+// What each permission is, in the CLI's own terms, and how far it reaches. The page never invents a grant: the options come from the bridge.
+const OPTION_TEXT = {
+  'agy-level:accept-edits': ['Tự duyệt việc sửa file', '--mode accept-edits. Lệnh và đường dẫn ngoài workspace vẫn bị hỏi, nên vẫn bị từ chối.'],
+  'agy-level:auto': ['Chế độ tự động của Antigravity', '--mode auto: Antigravity tự quyết định hành động của nó.'],
+  'agy-level:full': ['Bỏ qua mọi yêu cầu quyền', '--dangerously-skip-permissions: mọi thao tác được duyệt, kể cả lệnh và đường dẫn ngoài workspace.'],
+  'codex-add-dir': ['Mở thêm một thư mục để ghi', '--add-dir <thư mục>: chỉ đúng thư mục này; mọi thư mục khác ngoài workspace vẫn bị chặn.'],
+  'opencode-allow:bash': ['Cho phép chạy lệnh shell', 'bash=allow cho lần này. Shell của OpenCode ghi được cả ra ngoài workspace.'],
+  'opencode-allow:edit': ['Cho phép sửa file', 'edit=allow cho lần này.'],
+  'opencode-auto': ['Duyệt mọi thứ không bị chặn rõ ràng', '--auto: tự duyệt mọi quyền mà cấu hình OpenCode không từ chối.']
+};
+const optionKey = option => option.elevation?.kind === 'agy-level' ? `agy-level:${option.elevation.level}`
+  : option.elevation?.kind === 'opencode-allow' ? `opencode-allow:${option.elevation.permission}` : option.kind;
+const elevationKey = e => e.kind === 'agy-level' ? `agy-level:${e.level}` : e.kind === 'opencode-allow' ? `opencode-allow:${e.permission}` : e.kind;
+function retryNote(task) {
+  const e = task.elevation;
+  const what = e ? `${(OPTION_TEXT[elevationKey(e)] || [e.kind])[0]}${e.kind === 'codex-add-dir' ? ` (${e.dir})` : ''}` : 'không rõ';
+  return `Đây là lần chạy lại của task ${task.retry_of.slice(0, 8)}, với thêm quyền chỉ cho lần chạy này: ${what}. Cài đặt của bạn không đổi.`;
+}
+let approvalsAt = 0;
+async function loadApprovals(force) {
+  if (!force && Date.now() - approvalsAt < 4000) return;
+  approvalsAt = Date.now();
+  try { state.approvals = (await api('approvals')).approvals; } catch { /* keep the list already on screen */ }
+  patch();
+}
+/** The option the page preselects: the one the bridge marked narrowest, unless the owner already picked another. */
+function pickedOption(view) {
+  const chosen = state.approvalPick[view.task_id];
+  if (Number.isInteger(chosen) && chosen >= 0 && chosen < view.options.length) return chosen;
+  const narrow = view.options.findIndex(option => option.narrowest);
+  return narrow >= 0 ? narrow : 0;
+}
+async function approveRerun(view, option) {
+  const typed = (state.approvalDir[view.task_id] || '').trim();
+  if (option.needs_dir && !typed) { notify('Nhập đường dẫn tuyệt đối của thư mục trước'); return; }
+  const elevation = option.needs_dir ? {kind: option.kind, dir: typed} : option.elevation;
+  const [title, note] = OPTION_TEXT[optionKey(option)] || [option.kind, ''];
+  if (!confirm(`Chạy lại task này với thêm quyền?\n\n${title}${option.needs_dir ? `: ${typed}` : ''}\n${note}\n\nChỉ áp dụng cho MỘT lần chạy: bridge tạo task mới từ đúng yêu cầu đã ghi của task cũ. Cài đặt của bạn không đổi và lần chạy sau không thừa hưởng quyền này.${option.wide ? '\n\nMức này RỘNG: nó mở nhiều hơn các hành động đã bị từ chối.' : ''}`)) return;
+  try {
+    await api(`tasks/${view.task_id}/approve`, {method: 'POST', body: {confirm: true, elevation}});
+    notify('Đã tạo task chạy lại');
+  } catch (error) { notify(error.message); }
+  await refresh(true);
+  await loadApprovals(true);
+}
+async function dismissRefusal(view) {
+  if (!confirm('Bỏ qua các hành động bị từ chối của task này?\n\nKhông chạy gì thêm. Việc này được ghi vào nhật ký quyết định.')) return;
+  try { await api(`tasks/${view.task_id}/dismiss`, {method: 'POST', body: {confirm: true}}); notify('Đã bỏ qua'); }
+  catch (error) { notify(error.message); }
+  await refresh(true);
+  await loadApprovals(true);
+}
+/** What a person decides on: the refused actions, then what the task can be given, then the two buttons. */
+function approvalBody(view) {
+  const denied = h('div', {}, h('div', {class: 'msg-head', text: 'Hành động bị từ chối'}),
+    h('div', {class: 'chips'}, view.denied.map(item => h('span', {
+      class: item.suspected ? 'chip suspected' : 'chip',
+      title: item.suspected ? 'Bridge chỉ suy ra từ văn bản của một lệnh thất bại; chưa chắc đây là từ chối quyền.' : 'CLI báo hành động này bị từ chối.',
+      text: `${item.suspected ? '? ' : ''}${item.display_name || item.action}`}))));
+  if (view.state === 'rerun') {
+    return [denied, h('div', {class: 'callout good'}, 'Đã chạy lại ở task ', view.rerun_task_id ? h('button', {class: 'link-btn', onclick: () => openTask(view.rerun_task_id), text: view.rerun_task_id.slice(0, 8)}) : '?', '.')];
+  }
+  if (view.state === 'dismissed') return [denied, h('div', {class: 'callout', text: 'Đã bỏ qua: không chạy gì thêm.'})];
+  if (!view.options.length) {
+    return [denied, h('div', {class: 'callout warn', text: 'Không có cách nâng quyền hẹp cho loại hành động này. Bạn chỉ có thể bỏ qua, hoặc đổi cấu hình của agent rồi giao lại.'}),
+      h('div', {class: 'chips'}, h('button', {class: 'btn small', onclick: () => dismissRefusal(view), text: 'Bỏ qua'}))];
+  }
+  const picked = pickedOption(view);
+  const option = view.options[picked];
+  const rows = view.options.map((item, index) => {
+    const [title, note] = OPTION_TEXT[optionKey(item)] || [item.kind, ''];
+    return h('label', {class: `option${index === picked ? ' picked' : ''}`},
+      h('input', {type: 'radio', name: `pick-${view.task_id}`, checked: index === picked, onchange: () => { state.approvalPick[view.task_id] = index; patch(); }}),
+      h('span', {}, h('strong', {text: title}), h('span', {class: 'muted', text: note}),
+        h('span', {class: 'chips'}, item.narrowest ? h('span', {class: 'pill ok', text: 'hẹp nhất'}) : null, item.wide ? h('span', {class: 'pill bad', text: 'rộng'}) : null)));
+  });
+  return [denied,
+    h('div', {class: 'msg-head', text: 'Quyền thêm, chỉ cho một lần chạy lại'}),
+    h('div', {class: 'option-list', role: 'radiogroup'}, rows),
+    option.needs_dir ? h('input', {type: 'text', class: 'search', 'aria-label': 'Thư mục được mở thêm', placeholder: 'Đường dẫn tuyệt đối của thư mục, ví dụ C:\\du-an\\build',
+      value: state.approvalDir[view.task_id] || '', oninput: event => { state.approvalDir[view.task_id] = event.target.value; }}) : null,
+    h('div', {class: 'chips'},
+      h('button', {class: 'btn primary small', onclick: () => approveRerun(view, option), text: 'Cho phép và chạy lại'}),
+      h('button', {class: 'btn small', onclick: () => dismissRefusal(view), text: 'Bỏ qua'})),
+    h('p', {class: 'muted', text: 'Task mới dùng đúng yêu cầu đã ghi của task cũ; quyền thêm chỉ nằm trong lần chạy đó, không đổi cài đặt nào của bạn.'})];
+}
+function approvalCard(view) {
+  return h('section', {class: 'card panel approval'},
+    h('div', {class: 'mission-head'}, h('div', {},
+      h('h2', {}, view.title || view.task_id.slice(0, 8), pill(view.status),
+        view.state === 'pending' ? h('span', {class: 'pill warn', text: 'Chờ duyệt'}) : null),
+      h('div', {class: 'meta-line muted mono', title: view.workspace}, `${view.agent} · ${folder(view.workspace)}${view.isolation === 'worktree' ? ' · worktree' : ''}`),
+      h('div', {class: 'meta-line muted'}, view.ended_at ? agoEl(view.ended_at, 'meta') : null, view.retry_of ? ` · chạy lại từ ${view.retry_of.slice(0, 8)}` : '',
+        h('button', {class: 'link-btn', onclick: () => openTask(view.task_id), text: 'Mở task'})))),
+    h('div', {class: 'approval-body'}, approvalBody(view)));
+}
+function approvalsView() {
+  const head = h('div', {class: 'page-head'}, h('div', {}, h('h1', {text: 'Duyệt'}),
+    h('p', {text: 'Task có hành động bị agent từ chối. Không CLI nào cho duyệt giữa chừng, nên bạn duyệt sau: chạy lại task như một task mới với thêm quyền cho đúng lần đó, hoặc bỏ qua.'})));
+  const note = h('p', {class: 'callout warn', text: 'Chỉ bạn duyệt được, ở trang này. Không có tool MCP nào để duyệt hay nâng quyền, nên một agent không tự duyệt được yêu cầu của chính nó.'});
+  const list = state.approvals;
+  if (!list) return [head, note, h('div', {class: 'card empty'}, state.connected ? 'Đang tải…' : 'Không đọc được hàng đợi.')];
+  const pending = list.filter(view => view.state === 'pending');
+  const settled = list.filter(view => view.state !== 'pending');
+  if (!list.length) return [head, note, h('div', {class: 'card empty'}, h('strong', {text: 'Chưa có gì cần duyệt'}), 'Khi một agent bị từ chối quyền ở một hành động, task đó hiện ở đây.')];
+  return [head, note,
+    pending.length ? h('h2', {class: 'section-title', text: `Chờ duyệt (${pending.length})`}) : h('div', {class: 'card empty'}, h('strong', {text: 'Không còn gì chờ duyệt'})),
+    ...pending.map(approvalCard),
+    settled.length ? h('h2', {class: 'section-title', text: `Đã xử lý (${settled.length})`}) : null,
+    ...settled.map(approvalCard)];
+}
+/** On the task page: the same card, for the one task being read. */
+function approvalPanel(task) {
+  const view = (state.approvals || []).find(item => item.task_id === task.task_id);
+  const el = details('approval', 'Duyệt hành động bị từ chối', ...(view ? approvalBody(view) : [h('p', {class: 'muted', text: 'Đang tải…'})]));
+  el.addEventListener('toggle', () => { if (el.open) void loadApprovals(true); });
+  if (!state.approvals) void loadApprovals(true);
+  return el;
+}
+
 /* ---------- Mission page: read the recorded plan, stop it, never start a step ---------- */
 let missionsAt = 0;
 /** A step changes state only when its task does, so the list is read when the page opens and then at most every 8 seconds. */
@@ -472,7 +597,7 @@ function reviewBody(task) {
     !task.applied_at && !task.discarded_at ? h('p', {class: 'muted', text: 'Đọc diff từng file ở mục "Thay đổi trong workspace" trước khi áp dụng.'}) : null,
     mine.length ? h('div', {}, h('div', {class: 'msg-head', text: 'Nhật ký quyết định'}),
       h('ul', {class: 'change-list'}, mine.map(item => h('li', {class: 'change-row'},
-        h('span', {class: `change-kind ${item.ok ? 'added' : 'deleted'}`, text: item.action === 'apply' ? 'Áp dụng' : 'Bỏ'}),
+        h('span', {class: `change-kind ${item.ok ? 'added' : 'deleted'}`, text: DECISION_LABEL[item.action] || item.action}),
         h('span', {class: 'change-path', text: `${item.ok ? '' : 'Bị từ chối: '}${item.detail}`}),
         h('span', {class: 'change-count mono', text: clock(item.at)}))))) : null
   ];
@@ -569,8 +694,9 @@ function detailView() {
   } else {
     answer = [
       task.final_response ? h('p', {class: 'text', text: task.final_response}) : h('p', {class: 'muted', text: `${agentName} không trả về phản hồi cuối.`}),
+      task.retry_of ? h('div', {class: 'callout', text: retryNote(task)}) : null,
       task.denied_actions.length ? h('div', {}, h('div', {class: 'msg-head', text: 'Thao tác bị từ chối quyền'}),
-        h('div', {class: 'chips'}, task.denied_actions.map(a => h('span', {class: 'chip', text: a.display_name || a.action})))) : null,
+        h('div', {class: 'chips'}, task.denied_actions.map(a => h('span', {class: a.suspected ? 'chip suspected' : 'chip', title: a.suspected ? 'Bridge chỉ suy ra từ văn bản của một lệnh thất bại.' : null, text: `${a.suspected ? '? ' : ''}${a.display_name || a.action}`})))) : null,
       scopeBody(task),
       cleanupBody(task),
       task.error ? h('div', {class: 'callout bad', text: task.error}) : null,
@@ -586,6 +712,7 @@ function detailView() {
 
   return h('article', {class: 'card detail'}, head, progress, h('div', {class: 'convo'}, asked, replied),
     changesPanel(task),
+    task.denied_actions.length && task.status !== 'running' && task.status !== 'queued' ? approvalPanel(task) : null,
     task.isolation === 'worktree' && task.status !== 'running' && task.status !== 'queued' ? reviewPanel(task) : null,
     details('steps', `Các bước ${agentName} báo cáo`, h('div', {id: 'steps-body'}, stepsBody(state.detail?.activity))),
     details('logs', `Log của tiến trình ${agentName}`, logs),
@@ -851,14 +978,15 @@ 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), label);
+  const badge = h('span', {class: 'nav-badge', hidden: true, 'aria-label': 'Số task chờ duyệt'});
+  const nav = (view, label, extra) => h('button', {'aria-current': state.view === view ? 'page' : null, onclick: () => { state.view = view; render(); }}, icon(view), label, extra);
   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('missions', 'Nhiệm vụ'), nav('usage', 'Sử dụng'), nav('settings', 'Cài đặt')),
+    h('nav', {class: 'nav', 'aria-label': 'Điều hướng'}, nav('tasks', 'Task'), nav('missions', 'Nhiệm vụ'), nav('approvals', 'Duyệt', badge), 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);
-  regions = {live, banner, main, view: state.view};
+  regions = {live, banner, main, badge, view: state.view};
   if (state.view === 'tasks') {
     regions.stats = h('section', {class: 'stats', 'aria-label': 'Tổng quan'});
     regions.list = h('div', {class: 'task-list', role: 'list'});
@@ -876,6 +1004,9 @@ function mount() {
   } else if (state.view === 'missions') {
     regions.missions = h('div', {class: 'mission-page'});
     main.append(regions.missions);
+  } else if (state.view === 'approvals') {
+    regions.approvals = h('div', {class: 'approvals-page'});
+    main.append(regions.approvals);
   } else {
     regions.settings = h('div', {});
     main.append(regions.settings);
@@ -896,6 +1027,9 @@ const stable = task => task.status === 'running' || task.status === 'queued' ? {
 function patch() {
   const o = state.overview;
   if (!regions || !o) return;
+  const waiting = o.tasks.filter(task => task.denied_actions?.length && !task.approval && task.status !== 'queued' && task.status !== 'running').length;
+  regions.badge.hidden = waiting === 0;
+  regions.badge.textContent = String(waiting);
   setRegion('live', String(state.connected), () => [h('span', {class: `dot${state.connected ? '' : ' off'}`}), h('span', {text: state.connected ? 'Đang cập nhật trực tiếp' : 'Mất kết nối tới bridge'})]);
   setRegion('banner', JSON.stringify([state.connected, o.warnings, o.update, o.permission?.level]), () => [
     !state.connected ? h('div', {class: 'banner', role: 'alert', text: 'Mất kết nối tới bridge. Dữ liệu bên dưới có thể đã cũ.'}) : null,
@@ -907,7 +1041,7 @@ function patch() {
     setRegion('list', JSON.stringify([state.q, state.filter, state.selected, o.budget?.task_tokens, o.tasks.map(t => stable(t))]), () => taskItems(o));
     regions.count.textContent = taskCount(o);
     const d = state.detail;
-    const detailKey = JSON.stringify([state.selected, state.logTab, state.changes, state.decisions, state.diff, d && {...d, activity: null, task: {...stable(d.task), stdout: '', stderr: '', stdout_bytes: 0, stderr_bytes: 0, stdout_truncated: false, stderr_truncated: false}}]);
+    const detailKey = JSON.stringify([state.selected, state.logTab, state.changes, state.decisions, state.approvals, state.approvalPick, state.diff, d && {...d, activity: null, task: {...stable(d.task), stdout: '', stderr: '', stdout_bytes: 0, stderr_bytes: 0, stdout_truncated: false, stderr_truncated: false}}]);
     const rebuilt = signatures.detail !== detailKey;
     setRegion('detail', detailKey, () => detailView());
     if (!rebuilt) patchLogs();
@@ -919,6 +1053,9 @@ function patch() {
   } else if (regions.view === 'missions') {
     loadMissions();
     setRegion('missions', JSON.stringify([o.missions, state.missions, state.selectedMission, state.plan]), () => missionsView(o));
+  } else if (regions.view === 'approvals') {
+    loadApprovals();
+    setRegion('approvals', JSON.stringify([state.approvals, state.approvalPick, state.connected]), () => approvalsView().filter(Boolean));
   } else {
     if (!state.models && !state.modelsLoading) loadModels();
     setRegion('settings', JSON.stringify([state.models, o.model, o.permission, o.effort, o.wait, o.budget && [o.budget.task_tokens, o.budget.day_tokens], o.soft_timeout, o.progress, o.cli, o.agents, o.default_agent, o.default_autonomy, o.concurrency, o.delegation, o.limits, o.allowed_workspaces, o.session_workspaces, o.server.mcp_endpoint]), () => settingsView(o));