@lardexx/arenacode 2.5.10 → 2.6.1

package/README.md

@@ -106,16 +106,41 @@ How the copy is built and tested: [`docs/TUI.md`](docs/TUI.md).
 |---|---|
 | `enter` | send · `shift+enter` newline |
 | `esc` | interrupt the turn · clear the input · quit |
-| `tab` | switch agent ↔ plan |
+| `tab` | switch mode: Build → Plan → Computer |
 | `ctrl+p` | command palette (`↑↓` select, `enter` run, `esc` close) |
 | `/` | slash commands with an inline list above the prompt |
-| `@file` | attach a file from the open folder |
+| `@file` | attach a file from the open folder (uploaded to `uploads/`) |
+| `@folder` | inline the folder listing in the task |
+| `ctrl+v` | paste: a clipboard image becomes `images/clipboard-*.png` and is attached |
 | `!command` | run a command locally |
 | `↑` / `↓` | prompt history (or move through the slash list) |
 | `pgup` / `pgdn` | scroll the transcript |
-| `ctrl+x` then | `q` quit · `n` new session · `l` task queue · `t` theme · `d` tool output · `b` sidebar · `s` stop |
+| `ctrl+x` then | `q` quit · `n` new session · `l` task queue · `t` theme · `a` Ask and Proceed / Proceed · `d` tool output · `s` stop |
 | `ctrl+c` | interrupt, then quit |
 
+**The same four flows as the desktop client.** The Windows app is the reference for how a task reaches the bridge,
+so the port reproduces it byte for byte:
+
+- **Paste an image.** `ctrl+v` reads the clipboard image, saves it as `<folder>/images/clipboard-YYYYMMDD-HHMMSS.png`
+  (the desktop's naming), uploads it and lists it in the task, so the agent can open it with `read`.
+- **Switch agent.** `tab` cycles the three modes of the desktop client — Build (`[ArenaCode mode: agent]`),
+  Plan (`[ArenaCode mode: plan]`) and Computer (`[ArenaCode mode: computer-agent]`) — and the first line of every
+  task is the desktop's own mode line, verbatim.
+- **Send a message.** `POST /task` carries `instruction`, `meta`, `agent_prompt` and `project_context`, the same
+  body the desktop client builds.
+- **Mention something.** `@file` is uploaded to `uploads/<timestamp>/` and named in `[attachments in the workspace: …]`;
+  `@folder` is inlined as `[folder contents … (n files, list only, not attached): …]`; missing paths outside the
+  folder are reported under `[paths on the PC: …]`. Messages follow the interface language (`it`, `en`, `es`).
+
+The exact strings are checked by `test/parity.js` against the ones extracted from `ArenaCode-x64.exe`.
+
+**Ask and Proceed / Proceed.** The desktop's Settings switch, `ctrl+x a` here (also `/ask`, `/proceed`,
+`--proceed`, and `arenacode config set approval proceed`). The default, **Ask and Proceed**, asks before commands,
+file changes and plans; in Computer mode it asks once, on the plan, and after that the commands run on their own
+while administrator commands still ask. **Proceed** approves its own plan, runs commands and installations and
+writes files without asking: turning it on shows the desktop's own warning (*"Pericolo: modalità Proceed"*).
+`--yes` is the older switch and still answers yes to commands and files, but never to a plan.
+
 **Dialogs.** Local actions open opencode-shaped dialogs — panel background, title on the left, `esc` on the right,
 the selected row painted in the primary colour, hints underneath: `Run once / Don't run` for terminal commands,
 `Approve / Reject / Revise` for the agent's plan, and file operations reported back to the bridge. `--yes` skips the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lardexx/arenacode",
-  "version": "2.5.10",
+  "version": "2.6.1",
   "description": "Terminal client for ArenaCode: talks to an arena-bridge, streams the Agent Mode timeline, and runs local commands and file operations on your PC. Node port of the ArenaCode desktop client.",
   "license": "MIT",
   "type": "commonjs",
@@ -19,7 +19,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node test/integration.js"
+    "test": "node test/integration.js && node test/parity.js"
   },
   "keywords": [
     "arenacode",

package/src/approval.js

@@ -0,0 +1,98 @@
+'use strict';
+
+// The desktop client has one setting, Settings → "Ask and Proceed" (default) or
+// "Proceed", and it changes every approval the client makes:
+//
+//   Ask and Proceed (IDE mode)   file changes wait for Accept/Reject, commands wait for Run
+//   Ask and Proceed (Computer)   one confirmation, on the plan; then commands run alone
+//                                (commands with administrator rights still ask)
+//   Proceed                      the client approves its own plan, runs commands and
+//                                installations and uses mouse and keyboard without asking
+//
+// `--yes` is the old switch of this client and keeps meaning "say yes to commands
+// and file changes", but never to a plan: a plan is the user's decision.
+const APPROVALS = ['ask', 'proceed'];
+
+const DANGER = {
+  it: {
+    title: 'Pericolo: modalità Proceed',
+    body:
+      'PERICOLO: in Proceed il Computer Agent approva da solo il piano, esegue comandi e installazioni ' +
+      'e usa mouse e tastiera senza chiedere. Può cancellare o modificare dati e programmi.',
+  },
+  en: {
+    title: 'Danger: Proceed mode',
+    body:
+      'DANGER: in Proceed the Computer Agent approves its own plan, runs commands and installations, and ' +
+      'uses mouse and keyboard without asking. It can delete or change data and programs.',
+  },
+  es: {
+    title: 'Peligro: modo Proceed',
+    body:
+      'PELIGRO: en Proceed el Computer Agent aprueba su propio plan, ejecuta comandos e instalaciones y ' +
+      'usa el ratón y el teclado sin preguntar. Puede borrar o modificar datos y programas.',
+  },
+};
+
+const HELP_TEXT = {
+  it: {
+    ide:
+      'Ask and Proceed: Arena chiede conferma per comandi, modifiche ai file e piani. ' +
+      'Proceed: esegue tutto da solo.',
+    computer:
+      'Ask and Proceed: il Computer Agent chiede conferma una sola volta, sul piano. Dopo ' +
+      "l'approvazione esegue i comandi da solo (i comandi con permessi di amministratore chiedono " +
+      'ancora conferma). Proceed: agisce da solo, senza chiedere nulla.',
+  },
+  en: {
+    ide:
+      'Ask and Proceed: Arena asks before commands, file changes and plans. ' +
+      'Proceed: does everything on its own.',
+    computer:
+      'Ask and Proceed: the Computer Agent asks for confirmation once, on the plan. After approval ' +
+      'it runs commands on its own (commands with administrator rights still ask). Proceed: it acts ' +
+      'on its own, without asking anything.',
+  },
+  es: {
+    ide:
+      'Ask and Proceed: Arena pide confirmación para comandos, cambios en archivos y planes. ' +
+      'Proceed: hace todo por sí solo.',
+    computer:
+      'Ask and Proceed: el Computer Agent pide confirmación una sola vez, sobre el plan. Tras ' +
+      'aprobarlo ejecuta los comandos por sí solo (los comandos con permisos de administrador ' +
+      'siguen pidiendo confirmación). Proceed: actúa por sí solo, sin preguntar nada.',
+  },
+};
+
+function normaliseApproval(value) {
+  return APPROVALS.includes(value) ? value : 'ask';
+}
+
+/**
+ * What the client should do with one request from the agent.
+ * kind: 'plan' | 'fs' | 'exec'
+ * Returns 'auto' (answer yes without showing anything) or 'ask' (show the card).
+ */
+function decide({ approval = 'ask', mode = 'agent', planApproved = false, kind, admin = false, yes = false }) {
+  if (normaliseApproval(approval) === 'proceed') return 'auto';
+  if (kind === 'plan') return 'ask';
+  if (yes) return 'auto';
+  if (kind === 'fs') return 'ask';
+  if (kind === 'exec') {
+    if (admin) return 'ask';
+    if (mode === 'computer-agent' && planApproved) return 'auto';
+    return 'ask';
+  }
+  return 'ask';
+}
+
+function dangerText(lang) {
+  return DANGER[lang] || DANGER.en;
+}
+
+function approvalHelp(lang, mode) {
+  const set = HELP_TEXT[lang] || HELP_TEXT.en;
+  return mode === 'computer-agent' ? set.computer : set.ide;
+}
+
+module.exports = { APPROVALS, decide, dangerText, approvalHelp, normaliseApproval, DANGER, HELP_TEXT };

package/src/attach.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { stamp } = require('./clipboard');
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '__pycache__',
+  '.git',
+  '.venv',
+  '.next',
+  '.cache',
+  '.idea',
+  '.vscode',
+  'dist',
+  'build',
+]);
+
+const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']);
+const MAX_FILES = 300;
+const MAX_BYTES = 64 * 1024 * 1024;
+
+const TEXT = {
+  it: {
+    attachments: '[allegati nel workspace: ',
+    folder: '[contenuto della cartella ',
+    empty: '[cartella vuota: ',
+    other: ' (altri %d file, solo elenco, non allegati): ',
+    paths: '[percorsi sul PC: ',
+    tooMany: 'troppi file (max %d) o file oltre %d MB',
+    noImage: 'Immagine negli appunti non leggibile.',
+    pasted: 'immagine allegata',
+  },
+  en: {
+    attachments: '[attachments in the workspace: ',
+    folder: '[folder contents ',
+    empty: '[empty folder: ',
+    other: ' (%d files, list only, not attached): ',
+    paths: '[paths on the PC: ',
+    tooMany: 'too many files (max %d) or files over %d MB',
+    noImage: 'Clipboard image could not be read.',
+    pasted: 'image attached',
+  },
+  es: {
+    attachments: '[adjuntos en el espacio de trabajo: ',
+    folder: '[contenido de la carpeta ',
+    empty: '[carpeta vacía: ',
+    other: ' (%d archivos, solo lista, no adjuntos): ',
+    paths: '[rutas en el PC: ',
+    tooMany: 'demasiados archivos (máx %d) o archivos de más de %d MB',
+    noImage: 'La imagen del portapapeles no se pudo leer.',
+    pasted: 'imagen adjunta',
+  },
+};
+
+function strings(lang) {
+  return TEXT[lang] || TEXT.en;
+}
+
+/** Lists the files of a folder the way the desktop client inlines them. */
+function folderListing(folder, rel, lang) {
+  const s = strings(lang);
+  const root = path.resolve(folder, rel);
+  const names = [];
+  let truncated = false;
+
+  const walk = (dir, prefix, depth) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (names.length >= MAX_FILES) {
+        truncated = true;
+        return;
+      }
+      if (e.name.startsWith('.') && depth === 0 && SKIP_DIRS.has(e.name)) continue;
+      if (SKIP_DIRS.has(e.name)) continue;
+      const childRel = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        walk(path.join(dir, e.name), childRel, depth + 1);
+      } else {
+        names.push(childRel);
+      }
+    }
+  };
+  walk(root, '', 0);
+
+  if (!names.length) return `${s.empty}${rel || '.'}]`;
+  const total = names.length + (truncated ? 1 : 0);
+  return `${s.folder}${rel || '.'}${s.other.replace('%d', total)}${names.join(', ')}${truncated ? ', …' : ''}]`;
+}
+
+function isInside(folder, abs) {
+  const rel = path.relative(folder, abs);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+async function upload(bridge, folder, abs, name) {
+  const stat = fs.statSync(abs);
+  if (stat.size > MAX_BYTES) return { error: 'size' };
+  const dir = `uploads/${stamp()}`;
+  const remote = `${dir}/${name}`;
+  const res = await bridge.upload(remote, fs.readFileSync(abs));
+  if (res.status !== 200) return { error: `HTTP ${res.status}` };
+  return { remote: (res.json && res.json.path) || remote, size: stat.size };
+}
+
+/**
+ * Turns `@refs` into the same instruction blocks the desktop client produces:
+ * files land in the bridge workspace, folders are inlined as a listing.
+ */
+async function attachRefs(bridge, folder, refs, { lang = 'en' } = {}) {
+  const s = strings(lang);
+  const uploaded = [];
+  const blocks = [];
+  const paths = [];
+  const warnings = [];
+
+  for (const ref of refs) {
+    const abs = path.resolve(folder, ref);
+    let exists = true;
+    let stat = null;
+    try {
+      stat = fs.statSync(abs);
+    } catch {
+      exists = false;
+    }
+    if (!exists) {
+      if (/^[a-zA-Z]:[\\/]/.test(ref) || ref.startsWith('/')) paths.push(ref);
+      else warnings.push(`not found: ${ref}`);
+      continue;
+    }
+    if (stat.isDirectory()) {
+      blocks.push(folderListing(folder, ref, lang));
+      continue;
+    }
+    const up = await upload(bridge, folder, abs, path.basename(abs));
+    if (up.error === 'size') {
+      warnings.push(s.tooMany.replace('%d', MAX_FILES).replace('%d', MAX_BYTES / (1024 * 1024)));
+      continue;
+    }
+    if (up.error) {
+      warnings.push(`upload failed: ${ref} (${up.error})`);
+      continue;
+    }
+    uploaded.push(up.remote);
+  }
+
+  return { uploaded, blocks, paths, warnings, s };
+}
+
+/** Moves a clipboard PNG into <folder>/images and uploads it, like the desktop. */
+async function attachImage(bridge, folder, tmpPng, { lang = 'en', name } = {}) {
+  const id = name || `clipboard-${stamp()}.png`;
+  const localDir = path.join(folder, 'images');
+  fs.mkdirSync(localDir, { recursive: true });
+  const local = path.join(localDir, id);
+  try {
+    fs.renameSync(tmpPng, local);
+  } catch {
+    fs.copyFileSync(tmpPng, local);
+    try {
+      fs.unlinkSync(tmpPng);
+    } catch {
+      /* ignore */
+    }
+  }
+  const up = await upload(bridge, folder, local, id);
+  if (up.error) return { error: up.error, local };
+  return { local, rel: path.relative(folder, local), remote: up.remote };
+}
+
+/** Appends the blocks the desktop appends to the instruction text. */
+function decorate(text, { uploaded = [], blocks = [], paths = [], lang = 'en' } = {}) {
+  const s = strings(lang);
+  const extra = [...blocks];
+  if (uploaded.length) extra.push(`${s.attachments}${uploaded.join(', ')}]`);
+  if (paths.length) extra.push(`${s.paths}${paths.join(', ')}]`);
+  if (!extra.length) return text;
+  return `${text}\n\n${extra.join('\n\n')}`;
+}
+
+module.exports = { attachRefs, attachImage, decorate, folderListing, strings, IMAGE_EXT, MAX_FILES, MAX_BYTES };

package/src/cli.js

@@ -9,6 +9,10 @@ const {
   resolveUrl, resolveKey, openFolder,
 } = require('./config');
 const { Bridge } = require('./bridge');
+const { MODE_LINES, MODES, normaliseMode } = require('./modes');
+const { attachRefs, decorate } = require('./attach');
+const { decide, dangerText, normaliseApproval } = require('./approval');
+const session = require('./session');
 const { buildMeta, readProjectContext } = require('./meta');
 const { followTask } = require('./turn');
 const { c, write, ask, banner, truncate, indentLines } = require('./ui');
@@ -30,23 +34,12 @@ const INSTALL_HINT = process.platform === 'win32'
   ? 'npm install -g @lardexx/arenacode   (then reopen the terminal)'
   : 'npm install -g @lardexx/arenacode';
 
-const MODE_LINES = {
-  agent:
-    '[ArenaCode mode: agent]\n' +
-    'AGENT MODE (not plan mode). Carry the task out directly: do not make a plan, do not send ui plan, ' +
-    'do not write a plan. This line overrides any plan instruction from earlier tasks or from the chat, ' +
-    'even if you remember one. Work, verify each change, and reply.',
-  plan:
-    '[ArenaCode mode: plan]\n' +
-    'PLAN MODE. Send the plan first with `ui plan`: the steps, the files involved, the risks and what you ' +
-    'will not do. Then stop and wait for the user to approve it before acting.',
-};
 
 // --------------------------------------------------------------------------- //
 // argument parsing
 // --------------------------------------------------------------------------- //
 
-const BOOLEAN_FLAGS = new Set(['yes', 'json', 'help', 'quiet', 'version', 'confirm-writes', 'no-pc', 'piped']);
+const BOOLEAN_FLAGS = new Set(['yes', 'json', 'help', 'quiet', 'version', 'confirm-writes', 'no-pc', 'piped', 'proceed', 'ask']);
 
 function parseArgs(argv) {
   const flags = {};
@@ -104,11 +97,12 @@ function context(flags) {
     folder,
     device,
     lang: flags.lang || cfg.lang || 'it',
-    mode: flags.mode === 'plan' ? 'plan' : flags.mode === 'agent' ? 'agent' : cfg.mode || 'agent',
+    mode: normaliseMode(flags.mode || cfg.mode || 'agent'),
     pcAccess: flags['no-pc'] ? false : cfg.pc_access !== false,
     yes: Boolean(flags.yes),
     json: Boolean(flags.json),
     confirmWrites: Boolean(flags['confirm-writes']),
+    approval: normaliseApproval(flags.proceed ? 'proceed' : flags.ask ? 'ask' : cfg.approval),
     idleTimeout: Number(flags['idle-timeout'] || cfg.idle_timeout || 180),
     bridge: new Bridge(url, key, device),
   };
@@ -200,7 +194,13 @@ function cmdConfig(positional, flags) {
     const name = key;
     const val = rest.join(' ');
     if (!name || val === '') {
-      write(`usage: ${SELF} config set <url|key|lang|mode|pc_access> <value>`);
+      write(`usage: ${SELF} config set <url|key|lang|mode|approval|pc_access> <value>`);
+      return 2;
+    }
+    if (name === 'approval' && !['ask', 'proceed'].includes(String(val))) {
+      write(c.red('  ✗ approval must be ask or proceed'));
+      write(c.gray(`    ask      ${'Ask and Proceed'}: the client asks before commands, file changes and plans`));
+      write(c.gray(`    proceed  Proceed: the client does everything on its own`));
       return 2;
     }
     const patch = {};
@@ -209,6 +209,12 @@ function cmdConfig(positional, flags) {
     else patch[name] = val;
     const file = patchConfig(patch);
     write(`  ${c.green('✓')} ${name} saved ${c.gray(file)}`);
+    if (name === 'approval' && patch.approval === 'proceed') {
+      const d = dangerText(cfg.lang);
+      write('');
+      write(`  ${c.bold(c.red('⚠ ' + d.title))}`);
+      write(indentLines(c.yellow(d.body), '  '));
+    }
     return 0;
   }
   if (action === 'clear') {
@@ -292,6 +298,7 @@ async function createTask(ctx, instruction, { extraInstructions = '' } = {}) {
   if (extraInstructions) body.instruction = `${instruction}\n\n${extraInstructions}`;
 
   const res = await ctx.bridge.createTask(body);
+  if (res.status === 202 || res.status === 200) session.remember(res.json && res.json.task_id, ctx.mode);
   if (res.status !== 202 && res.status !== 200) {
     const reason = (res.json && (res.json.error || res.json.hint)) || `HTTP ${res.status}`;
     throw new Error(reason);
@@ -303,23 +310,15 @@ async function runInstruction(ctx, text, { attachments = [] } = {}) {
   let instruction = `${MODE_LINES[ctx.mode] || MODE_LINES.agent}\n${text}`;
 
   if (attachments.length) {
-    const uploaded = [];
-    for (const file of attachments) {
-      const abs = path.resolve(file);
-      if (!fs.existsSync(abs)) {
-        write(c.yellow(`  ! missing attachment: ${file}`));
-        continue;
-      }
-      const name = `attachments/${Date.now()}-${path.basename(abs)}`;
-      const res = await ctx.bridge.upload(name, fs.readFileSync(abs));
-      if (res.status !== 200) {
-        write(c.yellow(`  ! upload failed: ${file}`));
-        continue;
-      }
-      uploaded.push(res.json.path);
-      write(`  ${c.green('↑')} ${c.gray(`${path.basename(abs)} → ${res.json.path} (${res.json.size} B)`)}`);
-    }
-    if (uploaded.length) instruction += `\n\n[attachments in the workspace: ${uploaded.join(', ')}]`;
+    const att = await attachRefs(ctx.bridge, ctx.folder, attachments, { lang: ctx.lang });
+    for (const w of att.warnings) write(c.yellow(`  ! ${w}`));
+    for (const remote of att.uploaded) write(`  ${c.green('↑')} ${c.gray(remote)}`);
+    instruction = decorate(instruction, {
+      uploaded: att.uploaded,
+      blocks: att.blocks,
+      paths: att.paths,
+      lang: ctx.lang,
+    });
   }
 
   let taskId = null;
@@ -339,6 +338,7 @@ async function runInstruction(ctx, text, { attachments = [] } = {}) {
       folder: ctx.folder,
       lang: ctx.lang,
       yes: ctx.yes,
+      approval: ctx.approval,
       confirmWrites: ctx.confirmWrites,
       idleTimeout: ctx.idleTimeout,
     });
@@ -398,6 +398,7 @@ async function cmdUi(flags) {
     lang: ctx.lang,
     mode: ctx.mode,
     yes: ctx.yes,
+    approval: ctx.approval,
     confirmWrites: ctx.confirmWrites,
   });
   await app.start();
@@ -756,11 +757,13 @@ function help() {
   write(`  ${c.cyan('options')}`);
   write(`    --folder <dir>             open folder (the project the agent works on)`);
   write(`    --url <url> --key <key>    override the saved bridge settings`);
-  write(`    --mode agent|plan          task mode (default: ${c.gray('agent')})`);
+  write(`    --mode agent|plan|computer-agent   task mode (default: ${c.gray('agent')})`);
   write(`    --lang it|en|es            language for instructions and cards`);
   write(`    --no-pc                    tell the agent the PC terminal is off`);
   write(`    --yes                      run local commands without asking`);
-  write(`    --confirm-writes           ask before write/replace/rm/mv on your folder`);
+  write(`    --ask                      Ask and Proceed: ask before commands, file changes and plans (default)
+    --proceed                  Proceed: approve the plan and run everything without asking
+    --confirm-writes           ask before write/replace/rm/mv on your folder`);
   write(`    --attach a,b               upload files with the task`);
   write(`    --json                     raw JSON output where available`);
   write('');

package/src/clipboard.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+// The desktop client stores a pasted screenshot as <folder>\images\clipboard-YYYYMMDD-HHMMSS.png
+function stamp(d = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return (
+    `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-` +
+    `${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`
+  );
+}
+
+function isPng(buf) {
+  return Buffer.isBuffer(buf) && buf.length > 8 && buf.subarray(0, 8).equals(PNG_MAGIC);
+}
+
+// Windows: System.Windows.Forms.Clipboard needs an STA thread, so run
+// PowerShell with -STA. The image is written straight to `dest`.
+function grabWindows(dest) {
+  const script = [
+    'Add-Type -AssemblyName System.Windows.Forms',
+    'Add-Type -AssemblyName System.Drawing',
+    '$img = [System.Windows.Forms.Clipboard]::GetImage()',
+    'if ($null -eq $img) { Write-Output "none"; exit 2 }',
+    `$img.Save('${dest.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    '$img.Dispose()',
+    'Write-Output "ok"',
+  ].join('; ');
+  for (const exe of ['powershell', 'pwsh']) {
+    const r = spawnSync(exe, ['-NoProfile', '-NonInteractive', '-STA', '-Command', script], {
+      timeout: 20_000,
+      windowsHide: true,
+    });
+    if (r.error && r.error.code === 'ENOENT') continue;
+    if (r.status === 0 && fs.existsSync(dest) && fs.statSync(dest).size > 0) return true;
+    // No image on the clipboard, or no PowerShell: nothing to paste.
+    if (r.status === 2) return false;
+    return false;
+  }
+  return false;
+}
+
+function grabUnix(dest) {
+  const attempts = [
+    ['wl-paste', ['--no-newline', '--type', 'image/png']],
+    ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o']],
+  ];
+  for (const [cmd, args] of attempts) {
+    const r = spawnSync(cmd, args, { timeout: 10_000, maxBuffer: 64 * 1024 * 1024 });
+    if (r.error) continue;
+    if (r.status === 0 && isPng(r.stdout)) {
+      fs.writeFileSync(dest, r.stdout);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Saves the image currently on the clipboard as a PNG in `dest`.
+ * Returns true when an image was written, false when the clipboard holds
+ * no image (or the platform has no clipboard access).
+ */
+function grabImage(dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  // test/automation hook: treat this file as the clipboard image
+  const hook = process.env.ARENACODE_CLIPBOARD_IMAGE;
+  if (hook) {
+    try {
+      if (fs.existsSync(hook)) {
+        fs.copyFileSync(hook, dest);
+        return true;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  try {
+    if (process.platform === 'win32') return grabWindows(dest);
+    return grabUnix(dest);
+  } catch {
+    return false;
+  }
+}
+
+/** Text on the clipboard, or '' when there is none. */
+function readClipboardText() {
+  try {
+    if (process.platform === 'win32') {
+      for (const exe of ['powershell', 'pwsh']) {
+        const r = spawnSync(exe, ['-NoProfile', '-NonInteractive', '-Command', 'Get-Clipboard -Raw'], {
+          timeout: 10_000,
+          encoding: 'utf8',
+          windowsHide: true,
+        });
+        if (r.error && r.error.code === 'ENOENT') continue;
+        return r.status === 0 && r.stdout ? r.stdout.replace(/\r\n/g, '\n').replace(/\n$/, '') : '';
+      }
+      return '';
+    }
+    for (const [cmd, args] of [
+      ['wl-paste', ['--no-newline']],
+      ['xclip', ['-selection', 'clipboard', '-o']],
+    ]) {
+      const r = spawnSync(cmd, args, { timeout: 10_000, encoding: 'utf8' });
+      if (!r.error && r.status === 0) return r.stdout || '';
+    }
+  } catch {
+    /* ignore */
+  }
+  return '';
+}
+
+/** True when the clipboard looks like it holds an image (cheap check, no write). */
+function hasImage() {
+  const tmp = path.join(require('os').tmpdir(), `arenacode-probe-${process.pid}-${Date.now()}.png`);
+  const ok = grabImage(tmp);
+  if (ok) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+      /* ignore */
+    }
+  }
+  return ok;
+}
+
+module.exports = { grabImage, readClipboardText, hasImage, stamp, isPng };

package/src/config.js

@@ -29,6 +29,7 @@ const DEFAULTS = {
   folder: '',
   lang: 'it',
   mode: 'agent',
+  approval: 'ask',
   pc_access: true,
   device: '',
   vision: false,

package/src/local.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const { decide } = require('./approval');
+const session = require('./session');
+
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -98,7 +101,18 @@ async function handleLocalExec(bridge, taskId, request, opts) {
   if (admin) write(`  ${c.yellow('!')} ${t(lang, 'Richiede i permessi di amministratore: qui il comando gira senza UAC.', 'Needs administrator rights: here it runs without UAC.', 'Necesita permisos de administrador: aquí se ejecuta sin UAC.')}`);
   if (sandboxReason) write(`  ${c.yellow('!')} ${t(lang, 'L’agente chiede di installare sul PC', 'The agent asks to install on the PC', 'El agente pide instalar en el PC')}: ${c.gray(sandboxReason)}`);
 
-  let approved = opts.yes === true;
+  const verdict = decide({
+    approval: opts.approval,
+    mode: session.modeOf(taskId),
+    planApproved: session.planApproved(taskId),
+    kind: 'exec',
+    admin: Boolean(admin),
+    yes: opts.yes === true,
+  });
+  let approved = verdict === 'auto';
+  if (verdict === 'auto') {
+    write(`  ${c.green('✓')} ${c.gray(t(lang, 'approvato dal client (Proceed)', 'approved by the client (Proceed)', 'aprobado por el cliente (Proceed)'))}`);
+  }
   if (!approved) {
     const key = await askKey(`  ${t(lang, 'Eseguo? [r] sì  [d] no', 'Run it? [r] yes  [d] no', '¿Ejecuto? [r] sí  [d] no')} `, ['r', 'd']);
     approved = key === 'r';
@@ -368,7 +382,18 @@ async function handleLocalFs(bridge, taskId, request, opts) {
   write(`  ${c.bold(c.yellow('▤ files'))} ${c.dim('·')} ${c.cyan(op)} ${c.gray(request.path || '.')}${request.to ? c.gray(` → ${request.to}`) : ''}`);
 
   const mutating = ['write', 'replace', 'rm', 'mv', 'mkdir'].includes(op);
-  if (mutating && opts.confirmWrites) {
+  const verdict = mutating
+    ? decide({
+        approval: opts.approval,
+        mode: session.modeOf(taskId),
+        planApproved: session.planApproved(taskId),
+        kind: 'fs',
+        yes: opts.yes === true,
+      })
+    : 'auto';
+  // --confirm-writes keeps asking even when the client runs in Proceed
+  const mustAsk = mutating && (verdict === 'ask' || opts.confirmWrites);
+  if (mustAsk) {
     const key = await askKey(`  ${t(lang, 'Applico? [s] sì  [n] no', 'Apply? [y] yes  [n] no', '¿Aplico? [s] sí  [n] no')} `, ['s', 'y', 'n']);
     if (key === 'n') {
       await bridge.localResult(taskId, { rid, output: JSON.stringify({ ok: false, error: 'rejected by the user' }), code: 1 });
@@ -406,6 +431,20 @@ async function handleLocalUi(bridge, taskId, request, opts) {
   const lang = opts.lang;
 
   if (op === 'plan') {
+    const planVerdict = decide({
+      approval: opts.approval,
+      mode: session.modeOf(taskId),
+      kind: 'plan',
+      yes: opts.yes === true,
+    });
+    if (planVerdict === 'auto') {
+      session.markPlanApproved(taskId);
+      write('');
+      write(`  ${c.bold(c.magenta('✦ plan'))} ${c.dim('·')} ${t(lang, 'approvato dal client (Proceed)', 'approved by the client (Proceed)', 'aprobado por el cliente (Proceed)')}`);
+      write(indentLines(request.text || '', '    '));
+      await bridge.localResult(taskId, { rid, output: JSON.stringify({ ok: true, approved: true }), code: 0 });
+      return true;
+    }
     write('');
     write(`  ${c.bold(c.magenta('✦ plan'))} ${c.dim('·')} ${t(lang, 'da approvare', 'to approve', 'para aprobar')}`);
     write(indentLines(request.text || '', '    '));
@@ -415,6 +454,7 @@ async function handleLocalUi(bridge, taskId, request, opts) {
       ['a', 'r', 'f'],
     );
     if (key === 'a') {
+      session.markPlanApproved(taskId);
       await bridge.localResult(taskId, { rid, output: JSON.stringify({ ok: true, approved: true }), code: 0 });
       write(`  ${c.green('✓')} ${t(lang, 'piano approvato', 'plan approved', 'plan aprobado')}`);
     } else if (key === 'f') {

package/src/modes.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// Mode lines copied verbatim from the Windows client (ArenaCode-x64.exe, UTF-16
+// string table). The first line of every task must be one of these: the agent
+// treats it as the only valid mode for that task.
+const MODE_LINES = {
+  agent:
+    '[ArenaCode mode: agent]\n' +
+    'AGENT MODE (not plan mode). Carry the task out directly: do not make a plan, do not send ui plan, ' +
+    'do not write a plan. This line overrides any plan instruction from earlier tasks or from the chat, ' +
+    'even if you remember one. Work, verify each change, and reply.',
+  plan:
+    '[ArenaCode mode: plan]\n' +
+    'PLAN ONLY until the plan is approved. Do not edit files, do not run commands and do not change ' +
+    'anything on the PC. Study the request and the project (read-only), then send a short numbered plan ' +
+    'with the command python3 bridge/agentctl.py ui plan <task id> --text "..." (steps, files involved, ' +
+    'risks, what you will not do). Wait for its result. If it says ok:true, the user approved: carry the ' +
+    'plan out now, in this same turn, step by step, and report what you changed. If it says revise:true ' +
+    'with feedback, the user wants a different plan: reword the plan taking the feedback into account and ' +
+    'send it again with ui plan, in this same turn. If it is refused or returns an error, do not change ' +
+    'anything and reply.',
+  'computer-agent': '[ArenaCode mode: computer-agent]',
+  'plan-approved':
+    '[ArenaCode mode: plan approved]\n' +
+    'The user approved the plan in your previous message. Carry it out now, step by step, following that ' +
+    'plan. At the end, report what you changed.',
+};
+
+// The three modes the desktop client can start a task in, in the order tab
+// cycles through them.
+const MODES = ['agent', 'plan', 'computer-agent'];
+
+const MODE_LABELS = {
+  agent: 'Build',
+  plan: 'Plan',
+  'computer-agent': 'Computer',
+};
+
+function modeLabel(mode) {
+  return MODE_LABELS[mode] || MODE_LABELS.agent;
+}
+
+function nextMode(mode) {
+  const i = MODES.indexOf(mode);
+  return MODES[(i < 0 ? 0 : i + 1) % MODES.length];
+}
+
+function normaliseMode(mode) {
+  const m = String(mode || '').toLowerCase();
+  if (m === 'computer' || m === 'computer-agent' || m === 'computer_agent') return 'computer-agent';
+  if (m === 'plan') return 'plan';
+  return 'agent';
+}
+
+module.exports = { MODE_LINES, MODES, MODE_LABELS, modeLabel, nextMode, normaliseMode };

package/src/session.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// Per-task state the approval rules need: the mode the task was started in and
+// whether its plan has already been approved (Computer Agent mode runs its
+// commands alone after that one approval).
+const tasks = new Map();
+
+function remember(taskId, mode) {
+  if (!taskId) return;
+  tasks.set(taskId, { mode: mode || 'agent', planApproved: false });
+}
+
+function modeOf(taskId) {
+  const t = tasks.get(taskId);
+  return t ? t.mode : 'agent';
+}
+
+function markPlanApproved(taskId) {
+  const t = tasks.get(taskId);
+  if (t) t.planApproved = true;
+  else if (taskId) tasks.set(taskId, { mode: 'agent', planApproved: true });
+}
+
+function planApproved(taskId) {
+  const t = tasks.get(taskId);
+  return Boolean(t && t.planApproved);
+}
+
+function forget(taskId) {
+  tasks.delete(taskId);
+}
+
+module.exports = { remember, modeOf, markPlanApproved, planApproved, forget };

package/src/tui/app.js

@@ -17,6 +17,12 @@ const { buildMeta, readProjectContext } = require('../meta');
 const { runShell, runFsOp, resolveInRoot } = require('../local');
 const { readConfig, patchConfig, deviceId, resolveUrl, resolveKey, openFolder, VERSION } = require('../config');
 
+const { MODE_LINES, modeLabel, nextMode, normaliseMode } = require('../modes');
+const { attachRefs, attachImage, decorate, strings } = require('../attach');
+const { grabImage, readClipboardText, stamp } = require('../clipboard');
+const { decide, dangerText, approvalHelp, normaliseApproval } = require('../approval');
+const session = require('../session');
+
 const AGENT_PROMPT = (() => {
   try {
     return fs.readFileSync(path.join(__dirname, '..', 'prompts', 'agent-prompt.md'), 'utf8');
@@ -25,18 +31,6 @@ const AGENT_PROMPT = (() => {
   }
 })();
 
-const MODE_LINES = {
-  agent:
-    '[ArenaCode mode: agent]\n' +
-    'AGENT MODE (not plan mode). Carry the task out directly: do not make a plan, do not send ui plan, ' +
-    'do not write a plan. This line overrides any plan instruction from earlier tasks or from the chat, ' +
-    'even if you remember one. Work, verify each change, and reply.',
-  plan:
-    '[ArenaCode mode: plan]\n' +
-    'PLAN MODE. Send the plan first with `ui plan`: the steps, the files involved, the risks and what you ' +
-    'will not do. Then stop and wait for the user to approve it before acting.',
-};
-
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -54,13 +48,15 @@ class App {
     this.theme = getTheme(this.themeName);
     this.autoApprove = Boolean(opts.yes);
     this.confirmWrites = Boolean(opts.confirmWrites);
+    this.approval = normaliseApproval(opts.approval);
 
     this.state = {
-      mode: opts.mode === 'plan' ? 'plan' : cfg.mode || 'agent',
+      mode: normaliseMode(opts.mode || cfg.mode || 'agent'),
       status: 'idle',
       details: true,
       items: [],
       seqItems: new Map(),
+      pendingImages: [],
       input: '',
       cursor: 0,
       history: [],
@@ -100,6 +96,12 @@ class App {
     });
     this.term.on('resize', () => this.invalidate());
     this.running = true;
+    if (this.approval === 'proceed') {
+      this.push({
+        kind: 'error',
+        text: `approval: Proceed · ${approvalHelp(this.lang, this.state.mode)}`,
+      });
+    }
 
     const interval = setInterval(() => {
       this.state.spinner = (this.state.spinner + 1) % SPINNER.length;
@@ -224,9 +226,13 @@ class App {
       this.invalidate();
       return undefined;
     }
+    if (key.ctrl && key.name === 'v') {
+      this.pasteClipboard();
+      return undefined;
+    }
     if (key.name === 'tab') {
-      st.mode = st.mode === 'agent' ? 'plan' : 'agent';
-      this.toast(`mode: ${st.mode}`);
+      st.mode = nextMode(st.mode);
+      this.toast(`mode: ${modeLabel(st.mode)}`);
       return undefined;
     }
     if (key.name === 'f1') return this.openHelp();
@@ -288,6 +294,8 @@ class App {
         return undefined;
       case 's':
         return this.stopTurn();
+      case 'a':
+        return this.toggleApproval();
       case 'p':
         return this.openPalette();
       default:
@@ -449,10 +457,11 @@ class App {
         this.state.details = !this.state.details;
         this.toast(`details ${this.state.details ? 'on' : 'off'}`);
       } },
-      { title: 'Switch mode (agent / plan)', hint: 'tab', run: () => {
-        this.state.mode = this.state.mode === 'agent' ? 'plan' : 'agent';
-        this.toast(`mode: ${this.state.mode}`);
+      { title: 'Switch mode (Build / Plan / Computer)', hint: 'tab', run: () => {
+        this.state.mode = nextMode(this.state.mode);
+        this.toast(`mode: ${modeLabel(this.state.mode)}`);
       } },
+      { title: `Approval: ${this.approval === 'proceed' ? 'Proceed' : 'Ask and Proceed'}`, hint: 'ctrl+x a', run: () => this.toggleApproval() },
       { title: 'Theme', hint: 'ctrl+x t', run: () => {
         const names = themeNames();
         const next = names[(names.indexOf(this.themeName) + 1) % names.length];
@@ -473,17 +482,62 @@ class App {
 
   /** `/help`, `/new`, `/tasks` … — opencode-style slash commands */
   slashCommands() {
+    const by = (prefix) => {
+      const found = this.commands().find((cmd) => cmd.title.startsWith(prefix));
+      return () => (found ? found.run() : undefined);
+    };
     return [
-      { slash: '/new', title: 'Start a new session', hint: 'ctrl+x n', group: 'Session', run: () => this.commands()[1].run() },
+      { slash: '/new', title: 'Start a new session', hint: 'ctrl+x n', group: 'Session', run: by('New session') },
       { slash: '/tasks', title: 'Show the task queue', hint: 'ctrl+x l', group: 'Session', run: () => this.openTasks() },
-      { slash: '/mode', title: 'Switch agent / plan', hint: 'tab', group: 'Session', run: () => this.commands()[5].run() },
-      { slash: '/theme', title: 'Cycle the colour theme', hint: 'ctrl+x t', group: 'Session', run: () => this.commands()[6].run() },
-      { slash: '/status', title: 'Ping the bridge', hint: '', group: 'Session', run: () => this.commands()[7].run() },
+      { slash: '/mode', title: 'Switch agent / plan', hint: 'tab', group: 'Session', run: by('Switch mode') },
+      { slash: '/ask', title: 'Ask and Proceed: ask before commands, files and plans', hint: '', group: 'Session', run: () => this.setApproval('ask') },
+      { slash: '/proceed', title: 'Proceed: approve the plan and run everything without asking', hint: '', group: 'Session', run: () => this.setApproval('proceed') },
+      { slash: '/theme', title: 'Cycle the colour theme', hint: 'ctrl+x t', group: 'Session', run: by('Theme') },
+      { slash: '/status', title: 'Ping the bridge', hint: '', group: 'Session', run: by('Bridge status') },
       { slash: '/help', title: 'Every keybinding', hint: 'f1', group: 'Session', run: () => this.openHelp() },
       { slash: '/quit', title: 'Leave arenacode', hint: 'ctrl+x q', group: 'Session', run: () => this.quit() },
     ];
   }
 
+  /** Ask and Proceed ↔ Proceed, the desktop's Settings switch. */
+  async toggleApproval() {
+    await this.setApproval(this.approval === 'proceed' ? 'ask' : 'proceed');
+  }
+
+  async setApproval(mode) {
+    const next = normaliseApproval(mode);
+    if (next === this.approval) {
+      this.toast(`approval: ${next === 'proceed' ? 'Proceed' : 'Ask and Proceed'}`);
+      return;
+    }
+    if (next === 'proceed') {
+      const danger = dangerText(this.lang);
+      const answer = await this.confirm({
+        title: danger.title,
+        subject: danger.body,
+        options: [
+          { key: 'y', label: 'enable Proceed', tone: 'err' },
+          { key: 'n', label: 'keep Ask and Proceed', tone: 'ok' },
+        ],
+      });
+      if (answer !== 'y') {
+        this.toast('approval: Ask and Proceed');
+        return;
+      }
+    }
+    this.approval = next;
+    try {
+      patchConfig({ approval: next });
+    } catch {
+      /* a read-only HOME keeps the switch in memory only */
+    }
+    this.push({
+      kind: next === 'proceed' ? 'error' : 'system',
+      text: `approval: ${next === 'proceed' ? 'Proceed' : 'Ask and Proceed'} · ${approvalHelp(this.lang, this.state.mode)}`,
+    });
+    this.toast(`approval: ${next === 'proceed' ? 'Proceed' : 'Ask and Proceed'}`, next === 'proceed' ? 'warn' : 'ok');
+  }
+
   onOverlayKey(key) {
     const ov = this.state.overlay;
     if (key.name === 'escape') {
@@ -565,6 +619,42 @@ class App {
     }
   }
 
+  /** ctrl+v: a clipboard image becomes an attachment, otherwise text is pasted. */
+  async pasteClipboard() {
+    const st = this.state;
+    if (st.status === 'running') {
+      this.toast('a turn is running: press esc to stop', 'warn');
+      return;
+    }
+    if (!this.url) {
+      this.toast('no bridge URL: run arenacode init', 'error');
+      return;
+    }
+    const tmp = path.join(require('os').tmpdir(), `arenacode-clip-${stamp()}-${process.pid}.png`);
+    if (grabImage(tmp)) {
+      const res = await attachImage(this.bridge, this.folder, tmp, { lang: this.lang });
+      if (res.error) {
+        this.toast(strings(this.lang).noImage, 'error');
+        return;
+      }
+      st.pendingImages.push(res.remote);
+      this.push({ kind: 'system', text: `${strings(this.lang).pasted}: ${res.rel}` });
+      this.toast(`${strings(this.lang).pasted}: ${res.rel}`);
+      this.invalidate();
+      return;
+    }
+    const text = readClipboardText();
+    if (text) {
+      const before = st.input.slice(0, st.cursor);
+      const after = st.input.slice(st.cursor);
+      st.input = before + text + after;
+      st.cursor += text.length;
+      this.invalidate();
+    } else {
+      this.toast(strings(this.lang).noImage, 'warn');
+    }
+  }
+
   // ---------------------------------------------------------------- turn
   async submit(text) {
     const st = this.state;
@@ -590,18 +680,19 @@ class App {
       return;
     }
 
-    let instruction = text;
-    const attachments = [];
+    // @file uploads the file, @folder inlines its listing, exactly like the desktop client
     const refs = [...text.matchAll(/@([^\s]+)/g)].map((m) => m[1]);
-    for (const ref of refs) {
-      const abs = path.resolve(this.folder, ref);
-      if (!fs.existsSync(abs)) continue;
-      const name = `attachments/${Date.now()}-${path.basename(abs)}`;
-      const up = await this.bridge.upload(name, fs.readFileSync(abs));
-      if (up.status === 200) attachments.push(up.json.path);
-    }
-    if (attachments.length) {
-      instruction += `\n\n[attachments in the workspace: ${attachments.join(', ')}]`;
+    let instruction = text;
+    if (refs.length || st.pendingImages.length) {
+      const att = await attachRefs(this.bridge, this.folder, refs, { lang: this.lang });
+      for (const w of att.warnings) this.toast(w, 'warn');
+      const images = st.pendingImages.splice(0, st.pendingImages.length);
+      instruction = decorate(text, {
+        uploaded: [...att.uploaded, ...images],
+        blocks: att.blocks,
+        paths: att.paths,
+        lang: this.lang,
+      });
     }
 
     this.push({ kind: 'user', text: text.replace(/@([^\s]+)/g, '$1') });
@@ -625,6 +716,7 @@ class App {
       return;
     }
     st.taskId = res.json.task_id;
+    session.remember(st.taskId, st.mode);
     st.since = 0;
     st.seqItems.clear();
   }
@@ -805,7 +897,15 @@ class App {
 
     if (type === 'exec') {
       item.kindDetail = payload.command;
-      const answer = this.autoApprove
+      const verdict = decide({
+        approval: this.approval,
+        mode: session.modeOf(taskId),
+        planApproved: session.planApproved(taskId),
+        kind: 'exec',
+        admin: Boolean(payload.admin),
+        yes: this.autoApprove,
+      });
+      const answer = verdict === 'auto'
         ? 'y'
         : await this.confirm({
             title: 'terminal',
@@ -839,7 +939,16 @@ class App {
     if (type === 'fs') {
       const op = String(payload.op || '');
       const mutating = ['write', 'replace', 'rm', 'mv', 'mkdir'].includes(op);
-      if (mutating && this.confirmWrites) {
+      const fsVerdict = mutating
+        ? decide({
+            approval: this.approval,
+            mode: session.modeOf(taskId),
+            planApproved: session.planApproved(taskId),
+            kind: 'fs',
+            yes: this.autoApprove,
+          })
+        : 'auto';
+      if (mutating && (fsVerdict === 'ask' || this.confirmWrites)) {
         const approved = (await this.confirm({
           title: `file · ${op}`,
           subject: payload.path || '',
@@ -876,6 +985,20 @@ class App {
     if (type === 'ui') {
       const op = String(payload.op || '');
       if (op === 'plan') {
+        const planVerdict = decide({
+          approval: this.approval,
+          mode: session.modeOf(taskId),
+          kind: 'plan',
+          yes: false,
+        });
+        if (planVerdict === 'auto') {
+          session.markPlanApproved(taskId);
+          this.push({ kind: 'system', text: `plan approved by the client (Proceed): ${String(payload.text || '').split('\n')[0]}` });
+          await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify({ ok: true, approved: true }), code: 0 });
+          item.state = 'done';
+          this.invalidate();
+          return;
+        }
         const answer = await this.confirm({
           title: 'plan',
           subject: payload.text || '',
@@ -887,7 +1010,10 @@ class App {
           ],
         });
         let payloadOut;
-        if (answer === 'a') payloadOut = { ok: true, approved: true };
+        if (answer === 'a') {
+          payloadOut = { ok: true, approved: true };
+          session.markPlanApproved(taskId);
+        }
         else if (answer === 'f') {
           const feedback = await this.prompt('how should it be revised?');
           payloadOut = { ok: false, approved: false, revise: true, feedback: feedback || '' };
@@ -1032,12 +1158,14 @@ class App {
   }
 
   agentName() {
-    return this.state.mode === 'plan' ? 'Plan' : 'Build';
+    return modeLabel(this.state.mode);
   }
 
   agentColor() {
     // opencode gives each agent its own colour; Build is the secondary blue, Plan the accent violet
-    return this.state.mode === 'plan' ? this.theme.c.accent : this.theme.c.secondary;
+    if (this.state.mode === 'plan') return this.theme.c.accent;
+    if (this.state.mode === 'computer-agent') return this.theme.c.success;
+    return this.theme.c.secondary;
   }
 
   promptWidth(W) {
@@ -1054,7 +1182,7 @@ class App {
     const hints = busy
       ? []
       : [
-          ['tab', st.mode === 'plan' ? 'plan' : 'agents'],
+          ['tab', modeLabel(st.mode).toLowerCase()],
           ['ctrl+p', 'commands'],
         ];
     const block = W2.promptBlock(t, {
@@ -1339,14 +1467,16 @@ function HELP_ROWS() {
     ['Prompt', 'enter', 'send the message'],
     ['Prompt', 'shift+enter', 'newline'],
     ['Prompt', 'esc', 'interrupt the turn'],
-    ['Prompt', 'tab', 'switch agent / plan'],
+    ['Prompt', 'tab', 'switch mode: Build / Plan / Computer'],
     ['Prompt', 'ctrl+p', 'command palette'],
     ['Prompt', '/', 'slash commands'],
-    ['Prompt', '@', 'attach a file from the folder'],
+    ['Prompt', '@', 'mention a file or a folder'],
+    ['Prompt', 'ctrl+v', 'paste: a clipboard image becomes an attachment'],
     ['Prompt', '!', 'run a command locally'],
     ['Prompt', 'up / down', 'history'],
     ['Session', 'ctrl+x n', 'new session'],
     ['Session', 'ctrl+x l', 'task queue'],
+    ['Session', 'ctrl+x a', 'Ask and Proceed / Proceed'],
     ['Session', 'ctrl+x t', 'switch theme'],
     ['Session', 'ctrl+x d', 'toggle tool output'],
     ['Session', 'pgup / pgdn', 'scroll'],