agy-mcp-bridge 0.1.32 → 0.1.34

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/isolation/apply.js

@@ -54,13 +54,15 @@ const literal = (file) => `:(literal)${file}`;
 export async function applyWorktreeChanges(input) {
     try {
         const prefix = await prefixOf(input.toplevel, input.workspace);
-        const scope = prefix ? [prefix] : ['.'];
+        const scope = prefix ? [literal(prefix)] : ['.'];
         const owns = input.owns.map(normalizeOwn);
         if (!owns.length)
             throw new Refusal('The task declared no owned paths, so there is nothing it was allowed to change');
+        // Renames are never detected: with them on, `--name-only` lists only the new name, so a file moved out of a protected path
+        // would be deleted from the workspace without the owned-paths check ever seeing it.
         // Staging is only a way to include new files in the diff: it touches the worktree's own index, never the workspace.
         await git(input.worktree, ['add', '-A', '--', ...scope]);
-        const names = (await git(input.worktree, ['diff', '--cached', '--name-only', '-z', 'HEAD', '--', ...scope])).split('\0').filter(Boolean);
+        const names = (await git(input.worktree, ['diff', '--cached', '--no-renames', '--name-only', '-z', 'HEAD', '--', ...scope])).split('\0').filter(Boolean);
         if (!names.length)
             throw new Refusal('The worktree has no changes to apply');
         if (names.length > MAX_FILES)
@@ -70,10 +72,10 @@ export async function applyWorktreeChanges(input) {
         if (outside.length)
             throw new Refusal(`Files outside the task's owned paths were changed (${outside.slice(0, 5).join(', ')}); review them in the worktree`);
         // A symlink or a submodule pointer is more than text: it can point outside the workspace, so it is never applied from here.
-        const raw = (await git(input.worktree, ['diff', '--cached', '--raw', '-z', 'HEAD', '--', ...scope])).split('\0');
+        const raw = (await git(input.worktree, ['diff', '--cached', '--no-renames', '--raw', '-z', 'HEAD', '--', ...scope])).split('\0');
         if (raw.some(field => /^:(?:12|16)0000 /.test(field) || /^:\d+ (?:12|16)0000 /.test(field)))
             throw new Refusal('The change includes a symlink or a submodule, which is not applied from here; review it in the worktree');
-        const patch = await git(input.worktree, ['diff', '--cached', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', 'HEAD', '--', ...scope]);
+        const patch = await git(input.worktree, ['diff', '--cached', '--no-renames', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', 'HEAD', '--', ...scope]);
         if (Buffer.byteLength(patch) > MAX_PATCH_BYTES)
             throw new Refusal('The change is larger than the apply limit; review it in the worktree');
         // A file the owner is editing right now is theirs to merge by hand, even if the patch would happen to fit.

package/dist/src/isolation/diff.js

@@ -1,5 +1,7 @@
 import { execFile } from 'node:child_process';
+import { realpath } from 'node:fs/promises';
 import path from 'node:path';
+import { inside } from '../security/workspace.js';
 import { redact } from '../security/redact.js';
 import { gitEnvironment } from './apply.js';
 /**
@@ -28,6 +30,10 @@ function capture(cwd, args) {
 export async function worktreeFileDiff(worktree, file) {
     if (!isRelativeFilePath(file))
         throw new Error('path must be a relative path inside the worktree');
+    // A link in the worktree (a junction on Windows) can lead anywhere; the diff reads files, so the real location must stay inside it.
+    const [base, real] = await Promise.all([realpath(worktree), realpath(path.join(worktree, file)).catch(() => null)]);
+    if (real !== null && !inside(base, real))
+        throw new Error('path leaves the worktree through a link, so it is not read');
     const literal = `:(literal)${file}`;
     // Tracked files diff against the base commit; a file the agent created is not in the index, so it is shown as all added lines.
     const tracked = (await capture(worktree, ['ls-files', '--error-unmatch', '-z', '--', literal])).code === 0;

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

@@ -0,0 +1,200 @@
+# 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:** 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.
+
+## 1. Kết luận ngắn
+
+1. **Không CLI nào mà bridge dùng cho phép duyệt giữa chừng** trong chế độ không tương tác. Đo được trên `codex` và `opencode`; `agy` chưa đo lại được (mục 2.1).
+   - `codex exec`: không có sự kiện "xin quyền" nào, cả với `on-request` lẫn `never`. Hành động bị sandbox chặn chỉ hiện ra là một lệnh **thất bại** (`status: failed`, "Access ... is denied").
+   - `opencode run`: khi `permission` là `ask`, lời xin bị **tự từ chối ngay** (`auto-rejecting`) và run đi tiếp.
+2. Vì vậy MVP trung thực là **duyệt sau, không duyệt giữa chừng**: task kết thúc mà có hành động bị từ chối thì vào hàng đợi; chủ bridge chọn **"Cho phép và chạy lại"** (tạo task mới, `retry_of`, với quyền cao hơn *đúng cho một lần chạy đó*) hoặc **"Bỏ qua"**.
+3. **Bridge hôm nay chỉ nhìn thấy sự từ chối của `agy`** (`denied_actions`). `codex` chỉ được nhận diện khi item có status `declined`/`denied`, mà **chưa từng thấy** trong các lần đo; `opencode` báo `deniedActions: []` cố định dù có tín hiệu rõ ràng. Hàng đợi chỉ có nghĩa khi hai adapter này được dạy nhận ra sự từ chối (mục 4).
+4. Có cờ để nâng quyền **hẹp, một lần**: `codex --add-dir <dir>` (đã đo), `agy --mode accept-edits` (từ help, chưa đo), `opencode` qua `OPENCODE_CONFIG_CONTENT` theo từng lần chạy (cơ chế đã đo, tác dụng lên đúng quyền chưa đo).
+
+## 2. Đo đạc
+
+Máy: Windows 11, `agy` 1.4.12, `codex-cli` 0.163.0 (đăng nhập ChatGPT, `~/.codex/config.toml` có `[windows] sandbox = "elevated"`), `opencode` v2.2.5. Mọi lần đo chạy trong một repo git **tạm** (`%TEMP%\approval-probe-*\ws`, một commit `a.txt`), thư mục "ngoài workspace" là thư mục tạm riêng; không chạy agent trên repo của người dùng. Hai thư mục tạm trong thư mục home (để nằm ngoài `%TEMP%`) đã được xóa sau mỗi lần.
+
+### 2.1 `agy` — chưa đo được ở 1.4.12
+
+```
+agy --version                                         → 1.4.12
+agy --print "Reply with exactly: PROBE_OK" --output-format json
+→ Authentication required. Please visit the URL to log in: https://accounts.google.com/o/oauth2/auth?...
+```
+
+`agy` chưa đăng nhập trên máy này và việc đăng nhập là của chủ máy, nên mọi điều dưới đây về `agy` là **cờ đọc từ `agy --help`** hoặc **bằng chứng đã ghi trước đây**, không phải số đo mới:
+
+- Cờ (từ `agy --help`): `--mode accept-edits|auto|plan`, `--dangerously-skip-permissions` ("Auto-approve all tool permission requests without prompting"), `--sandbox` ("terminal restrictions"), `--output-format json`.
+- Bằng chứng đã ghi (`docs/VERIFICATION.md`, mục 4, trên `agy` 1.4.x trước đây): yêu cầu tạo file trong scratch workspace → CLI trả `SUCCESS`/exit 0 nhưng `denied_actions` chứa `write_file`, response rỗng; bridge báo `failed`.
+- Adapter hiện tại (`src/agents/antigravity.ts:39-44, 54-55`) đọc `envelope.denied_actions` (tối đa 100 mục, `action` và `display_name`) và biến task thành lỗi `Required tool permissions were denied; …`.
+
+**Chưa biết:** hình dạng `denied_actions` cho hành động khác `write_file` (chạy lệnh, đọc ngoài workspace); mức `--mode` nào mở được loại hành động nào; hành vi trên 1.4.12.
+
+### 2.2 `codex` 0.163.0
+
+Lệnh (cờ `--ask-for-approval` là cờ toàn cục, đứng **trước** `exec`):
+
+```
+codex --ask-for-approval <on-request|never> exec --json --sandbox <mode> --skip-git-repo-check --ephemeral --cd <ws> --color never -   (prompt qua stdin)
+```
+
+| # | Chính sách | Hành động yêu cầu | Kết quả đo |
+|---|---|---|---|
+| c4 | `never`, `read-only` | ghi `inside.txt` trong workspace | `command_execution` **`failed`**, exit 1, `Access to the path '…\ws\inside.txt' is denied`. Codex thoát 0, `turn.completed`, agent tự kể lại lỗi |
+| c2 | `on-request`, `workspace-write` | ghi `../outside/out.txt` (dưới `%TEMP%`) | **thành công**, exit 0 |
+| c3 | `never`, `workspace-write` | như c2 | **thành công**, exit 0 |
+| d1 | `on-request`, `workspace-write` | ghi file dưới thư mục home, **ngoài `%TEMP%`** | `failed`, exit 1, `Access … is denied`; file không tạo |
+| d2 | `never`, `workspace-write` | như d1 | `failed`, exit 1, như d1 |
+| e1 | `never`, `workspace-write --add-dir <A>` | ghi vào `A` và vào thư mục `B` không nêu tên | `A`: **thành công**; `B`: `failed`, exit 1, `Access … is denied` |
+| c1 | `on-request`, `workspace-write` | ghi `inside.txt` trong workspace | cả hai lần thử: `failed`, exit −1, `Failed to create unified exec process: orchestrator_helper_exit_nonzero: setup helper exited with status Some(143)` — lỗi hạ tầng của sandbox Windows, **không** phải từ chối quyền; chỉ xảy ra ở lần này, c2/c3 chạy ngay sau đó bình thường |
+
+Điều rút ra:
+
+- **Không có sự kiện xin quyền trong JSONL.** Các loại sự kiện thấy được: `thread.started`, `turn.started`, `item.started|completed` (`agent_message`, `command_execution`, `error`), `turn.completed`. `on-request` và `never` cho cùng kết quả trong `exec`: lệnh bị chặn thất bại ngay, "Execution failures are immediately returned to the model" đúng như `--help`.
+- **Không thấy `status: declined`/`denied` nào.** Điều kiện của adapter (`src/agents/codex.ts:62-63`) không bao giờ đúng với kiểu từ chối này, nên task kết thúc `completed` với câu trả lời của agent ("The write … was refused") và `denied_actions: []`. Bridge **không phân biệt được** "agent làm xong" với "agent bị chặn và kể lại".
+- `workspace-write` **cho ghi vào thư mục tạm** (c2, c3) nhưng **không** cho ghi vào thư mục home ngoài workspace (d1, d2). Hai điều này cho thấy "ngoài workspace" của codex không đồng nghĩa với "ngoài `%TEMP%`" (suy ra từ hai nhóm kết quả, không phải từ tài liệu).
+- `--add-dir <dir>` mở **đúng** thư mục nêu tên (e1) — đây là cách nâng quyền hẹp nhất cho "ghi ngoài workspace".
+- `--sandbox danger-full-access` **không đo**: chạy một agent không có sandbox nằm ngoài phạm vi cuộc điều tra này. Chỉ biết từ `--help` rằng cờ đó tồn tại.
+- Stderr của mọi lần chạy có `ERROR rmcp::transport::worker … http request failed … http://127.0.0.1:3000/mcp` (và `:8080`): codex nạp **MCP server khai báo trong `~/.codex/config.toml` của người dùng**, trong đó có chính bridge. Xem mục 7.
+
+### 2.3 `opencode` v2.2.5
+
+Lệnh (cách bridge chạy; cấu hình quyền đưa qua biến môi trường để không đụng file cấu hình của người dùng):
+
+```
+[OPENCODE_CONFIG_CONTENT='{"permission":{…}}'] opencode run --standalone --format json --model <free model> [--auto]   (prompt qua stdin)
+```
+
+| # | Cấu hình / cờ | Hành động yêu cầu | Kết quả đo |
+|---|---|---|---|
+| o1 | mặc định, không `--auto` | `printf … > inside.txt` bằng shell | `tool_use` shell **`completed`**, file tạo. **Không hỏi** |
+| o2 | mặc định, không `--auto` | ghi file thư mục home, **ngoài workspace**, bằng shell | `tool_use` shell **`completed`**, file được tạo. **Không hỏi, không chặn** |
+| o3 | `--auto` | như o2 | `completed`, file tạo |
+| o4 | `permission: {edit: ask, bash: ask}` | ghi `inside.txt` | `tool_use` shell **`status: "error"`**, `error`: *"This non-interactive run cannot ask the user for permission, so the request was rejected. Continue without this action."*; agent thử lại bằng tool `write`, cùng lỗi. Stderr: `! permission requested: shell (echo -n "IN_OK" > inside.txt, cat inside.txt); auto-rejecting` và `! permission requested: edit (inside.txt); auto-rejecting`. Run **đi tiếp**, thoát 0, agent kể lại việc bị từ chối |
+| o5 | như o4 + `--auto` | như o4 | `completed`, file tạo → `--auto` **ghi đè** `ask` |
+| o6 | `permission: {edit: deny, bash: deny}` | ghi `inside.txt` | shell/edit bị chặn; agent **chuyển sang tool khác**: gọi tool `execute` với các MCP tool của chủ máy (`tools.rea.*`, `tools.browser`), thử `capture_process_scenario` chạy `powershell.exe`, rồi tạo subagent. Các MCP tool đó trả `capability_unavailable` nên không có tác động; run dừng vì hết hạn mức free |
+
+Ghi chú về các số đo: o1 chạy trên `opencode/big-pickle`, o2–o6 (và chạy lại o1, bị 429) trên `opencode/deepseek-v4.1-flash-free`, vì `big-pickle` hết hạn mức miễn phí giữa chừng (`provider.free-limit`, 429). o4 có kết quả trên cả hai model.
+
+Điều rút ra:
+
+- **`opencode run` không có duyệt giữa chừng.** Lời xin quyền bị tự từ chối tức thì.
+- **Có tín hiệu từ chối rõ ràng và ổn định** để adapter đọc: `tool_use` có `part.state.status === "error"` và thông điệp chứa `cannot ask the user for permission`; stderr có dòng `permission requested: <tool> (<tham số>); auto-rejecting`. Adapter hiện trả `deniedActions: []` cố định (`src/agents/opencode.ts:91`).
+- **Cấu hình mặc định không từ chối gì cả** (o1, o2): hàng đợi duyệt chỉ có việc để làm với OpenCode khi chủ máy đã đặt `permission` thành `ask` (hoặc `deny`) trong cấu hình của OpenCode. Đây là điểm khác lớn với `agy`/`codex`.
+- **Từ chối `bash` không chặn việc chạy lệnh**: o6 cho thấy agent tìm đường khác qua MCP tool có sẵn trong cấu hình OpenCode của chủ máy. Một mức quyền chỉ nói về `bash`/`edit` là chưa đủ.
+- `opencode` có `serve`, `acp`, `api` và cờ `--server <url>`; có thể có API duyệt quyền trong server. **Chưa đánh giá**, ngoài MVP.
+
+## 3. Bridge nhìn thấy gì hôm nay
+
+| Agent | Nguồn tín hiệu từ chối | Kết quả trong bridge |
+|---|---|---|
+| `agy` | `denied_actions` trong JSON cuối (`antigravity.ts:39-44`) hoặc stderr khớp `auto-denied\|soft.denied\|permission.*cannot prompt` (dòng 54) | task `failed`, `denied_actions` điền |
+| `codex` | item `declined`/`denied` (`codex.ts:62-63`) — **chưa từng thấy** | sự từ chối kiểu sandbox (mục 2.2) → task `completed`, `denied_actions: []` |
+| `opencode` | không đọc gì (`opencode.ts:91`) | task `completed`, `denied_actions: []` |
+
+## 4. Việc adapter cần làm để hàng đợi có dữ liệu (thuộc B2, nếu thiết kế được duyệt)
+
+- **opencode** (tín hiệu chắc chắn): mỗi `tool_use` có `state.status === "error"` và thông điệp khớp `/cannot ask the user for permission/` → một `denied_action` `{action: part.tool, display_name: <tham số rút gọn, đã redact>}`. Một task có `denied_actions` thì chuyển sang `failed` như `agy`, hay giữ `completed` kèm cảnh báo? **Xem câu hỏi 3.**
+- **codex** (tín hiệu yếu): `command_execution` `failed` với output khớp `/access.*denied|permission denied|read-only file system/i` chỉ là **nghi ngờ** (agent có thể tự gây lỗi đó). Đề xuất: ghi vào hàng đợi như `suspected: true`, không đổi trạng thái task, và nói rõ trên giao diện rằng đó là suy đoán từ văn bản. Không dựa vào nó để tự động hóa gì.
+- **agy**: giữ nguyên.
+
+## 5. Thiết kế MVP: "duyệt sau, chạy lại một lần"
+
+### 5.1 Luồng
+
+1. Task kết thúc; có `denied_actions` (hoặc nghi ngờ, mục 4) → một **yêu cầu duyệt** hiện trong hàng đợi và ở panel của task.
+2. Chủ bridge mở yêu cầu, thấy từng hành động bị từ chối (văn bản do CLI cung cấp, hiển thị bằng `textContent`, cắt độ dài, đã redact) và các lựa chọn:
+   - **Cho phép và chạy lại**: hộp thoại chọn *mức nâng* (mặc định là mức hẹp nhất dùng được cho agent đó, xem 5.2), cảnh báo nó có thể lộ ra điều gì, và ô `confirm`. Kết quả: **task mới** `retry_of: <task cũ>`, cùng yêu cầu đã lưu, kèm `elevation` của đúng lần này.
+   - **Bỏ qua**: đóng yêu cầu, không chạy gì.
+3. Mọi quyết định ghi vào nhật ký (`appendDecision`): hành động `approve`/`rerun` (cho phép và chạy lại, kèm mức nâng và id task mới) và `dismiss`.
+
+### 5.2 Quyền nâng cho đúng một lần chạy (mức hẹp nhất mà cờ cho phép)
+
+| Agent | Mức hẹp → rộng | Mặc định | Có thể lộ ra |
+|---|---|---|---|
+| `agy` | `--mode accept-edits` → `--mode auto` → `--dangerously-skip-permissions` (từ `agy --help`; **chưa đo** hành động nào cần mức nào) | `accept-edits` nếu mọi hành động bị từ chối là ghi file (`write_file`, đã ghi nhận trước đây); còn lại chủ chọn tay, không đoán | `accept-edits`: sửa file trong workspace không hỏi. `auto`/`full`: lệnh và đường dẫn ngoài workspace, thông tin đăng nhập trên máy |
+| `codex` | `--add-dir <thư mục>` (**đã đo**, mở đúng thư mục nêu tên) → `--sandbox danger-full-access` (**chưa đo**) | `--add-dir` cho thư mục xuất hiện trong hành động bị từ chối, khi suy ra được; ngược lại chủ nhập thư mục | `--add-dir`: ghi vào thư mục đó. `danger-full-access`: toàn bộ ổ đĩa và mạng. `--ask-for-approval` **không** giúp gì (đo: `on-request` = `never` trong `exec`) |
+| `opencode` | patch quyền theo từng lần chạy qua `OPENCODE_CONFIG_CONTENT`, chỉ cho phép đúng quyền bị từ chối (ví dụ `{"permission":{"bash":"allow"}}`) → `--auto` | patch hẹp. **Chưa đo** patch này có thắng cấu hình `ask` toàn cục của người dùng không (cơ chế biến môi trường đã đo ở o4/o5; thứ tự ưu tiên thì chưa) | `bash: allow` ở OpenCode cho phép ghi **ngoài workspace** (o2) và mọi lệnh. `--auto` duyệt cả những gì cấu hình hỏi. MCP tool của chủ máy luôn nằm trong tầm với (o6) |
+
+### 5.3 Bảo đảm quyền chỉ áp dụng cho một lần chạy
+
+- Quyền nâng chỉ đi vào **đối số/biến môi trường của lần launch đó** (`extraArgs`/`customEnv` đã có sẵn trong `AgentTask`) và vào trường `elevation` của bản ghi task mới. **Không ghi** `permissions.json`, `workspaces.json`, cấu hình CLI hay biến môi trường của bridge; cài đặt toàn cục của chủ máy không đổi.
+- Task chạy lại **không kế thừa** gì cho task sau: chạy lại một task chạy lại cần một lần duyệt mới. `retry_of` chỉ để tra cứu, không mang quyền.
+- Mức nâng có **trần** là lựa chọn của chủ trong hộp thoại xác nhận; lúc launch, bridge kiểm tra lại `elevation` trên bản ghi chứ không tin giá trị nào khác (cùng tinh thần `lowerLevel` ở `permissions.ts`: không có đường nào làm quyền tăng sau khi chủ đã chọn).
+- Task cũ được giữ nguyên làm bằng chứng; task mới dùng **đúng yêu cầu đã lưu của task cũ** (không lấy văn bản từ đầu ra của agent).
+
+### 5.4 Chỉ chủ bridge duyệt, và agent không tự duyệt được
+
+- Chỉ qua **web UI** (`POST /ui/api/…`, `confirm: true`), cùng mô hình tin cậy với "Áp dụng/Bỏ worktree" (#40) và dừng mission. **Không thêm tool MCP nào** để xem hàng đợi, duyệt hay nâng quyền; `tests/http.test.ts` và `tests/bridge.test.ts` đều đếm số tool nên thêm nhầm sẽ đỏ.
+- Văn bản trong yêu cầu (tên hành động, tham số) do CLI/agent tạo ra nên **không tin cậy**: hiển thị bằng `textContent`, giới hạn độ dài, qua `redact`; không bao giờ đưa vào một câu lệnh hay vào prompt của lần chạy lại.
+- Một agent không thể tạo yêu cầu duyệt cho chính nó ngoài việc bị từ chối thật, và không có đường nào từ nội dung nó viết tới nút "Cho phép".
+
+### 5.5 Dữ liệu
+
+Không thêm kho trạng thái mới. Yêu cầu duyệt được **suy ra** từ bản ghi task (`denied_actions`, trường mới `retry_of`/`elevation`) và từ `decisions.jsonl` (đã có, chỉ thêm giá trị `approve`/`rerun`/`dismiss` vào `DecisionAction`). Một yêu cầu là "chờ" khi task có `denied_actions` và chưa có quyết định nào cho task đó. Hệ quả: khởi động lại bridge không làm mất hàng đợi, và nhật ký vẫn là nguồn duy nhất.
+
+### 5.6 Task `isolation: worktree`
+
+Đề xuất: lần chạy lại tạo **worktree mới từ HEAD** (sạch), worktree cũ giữ nguyên để chủ xem và bỏ. Cái giá: mất phần việc dở của lần đầu. Phương án khác (dùng lại worktree) giữ việc dở nhưng tái hiện đúng vấn đề đã ghi ở `docs/SMART-ROUTER-PLAN.md` (phạm vi là tổng hai lần). **Xem câu hỏi 2.**
+
+## 6. Ranh giới của MVP
+
+Ngoài MVP và chưa kiểm: duyệt giữa chừng (API server của OpenCode chưa đánh giá); mọi thứ về `agy` 1.4.12; hình dạng `denied_actions` ngoài `write_file`; `codex --sandbox danger-full-access`; patch cấu hình OpenCode có thắng cấu hình toàn cục không; hành vi trên Linux/macOS (mọi số đo ở trên là Windows).
+
+## 7. Quan sát ngoài phạm vi (không sửa trong PR này)
+
+1. **OpenCode `provider.free-limit` không được nhận là hết quota.** Run bị 429 `FreeUsageLimitError` ("Free usage limit reached. Connect a provider or subscribe to OpenCode Go to keep going, or switch models."): `isQuotaError` trả `false` cho cả thông điệp lẫn `provider.free-limit` (đã chạy), nên một pool có OpenCode **không failover** khi hạn mức miễn phí hết.
+2. **OpenCode chạy với MCP tool của chủ máy** (o6): từ chối `bash` không chặn việc thử chạy lệnh qua tool khác. Đáng cân nhắc cô lập cấu hình OpenCode của task (cấu hình riêng qua `OPENCODE_CONFIG_CONTENT`/`XDG_*`).
+3. **Codex nạp MCP server của người dùng, kể cả chính bridge** (stderr mục 2.2). Khi bridge đang chạy ở cổng đó, một task `codex` do bridge giao có thể gọi lại `antigravity_delegate` — một đường đệ quy chưa được chặn. Chưa đo (trong các lần đo bridge không chạy ở cổng 3000).
+4. Sandbox Windows của codex thỉnh thoảng thất bại ở khâu khởi tạo (c1, `Some(143)`); bridge sẽ thấy lệnh `failed` mà không có dấu hiệu từ chối.
+
+## 8. Câu hỏi cần chủ dự án quyết trước khi viết mã
+
+1. **Chấp nhận "duyệt sau"** (không duyệt giữa chừng) làm MVP? Đây là kết luận của các số đo ở mục 2.
+2. **Task worktree chạy lại**: worktree mới từ HEAD (đề xuất) hay dùng lại worktree cũ?
+3. **Task có `denied_actions` ở OpenCode/Codex**: giữ `completed` kèm cảnh báo, hay chuyển `failed` như `agy`? (Đổi trạng thái là đổi hành vi hiện tại, ảnh hưởng mission và pool failover.)
+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.32",
+  "version": "0.1.34",
   "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));