ucode-agent 1.62.4 → 1.62.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.62.4",
+  "version": "1.62.6",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on Google Gemini models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/attach.js

@@ -0,0 +1,118 @@
+/**
+ * attach.js — the "+ file" button: choosing reference files and turning them
+ * into something the model can use.
+ *
+ * The chooser is the computer's own (Finder on macOS, the Open dialog on
+ * Windows, zenity on Linux), so a sketch on the Desktop or a brief in
+ * Downloads is two clicks away. Where there is none, the caller falls back to
+ * a list of the project's files.
+ *
+ * Images go to the model as pictures; text files ride on the request as
+ * reference, under their own name. Anything else is refused with a reason.
+ */
+
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const IMAGE = { png: 'png', jpg: 'jpeg', jpeg: 'jpeg', gif: 'gif', webp: 'webp' };
+
+/** Bigger than this and a picture is refused rather than sent. */
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+/** Bigger than this and a text file is refused: it would crowd out the conversation. */
+export const MAX_TEXT_BYTES = 100 * 1024;
+
+/** Folders never listed in the fallback picker. */
+const SKIP = new Set(['node_modules', '.git', '.next', '.ucode', 'dist', 'build', '.turbo', '.vercel']);
+
+/** The native "choose a file" command for this platform, or null when there is none to try. */
+function chooserFor(platform) {
+  if (platform === 'darwin') {
+    return ['osascript', ['-e', 'POSIX path of (choose file with prompt "Add a file for ucode")']];
+  }
+  if (platform === 'win32') {
+    const script =
+      'Add-Type -AssemblyName System.Windows.Forms;' +
+      '$d = New-Object System.Windows.Forms.OpenFileDialog;' +
+      '$d.Title = "Add a file for ucode";' +
+      'if ($d.ShowDialog() -eq "OK") { [Console]::Out.Write($d.FileName) }';
+    return ['powershell.exe', ['-NoProfile', '-STA', '-Command', script]];
+  }
+  return ['zenity', ['--file-selection', '--title=Add a file for ucode']];
+}
+
+/**
+ * Ask the user for a file with the system's own dialog.
+ * Resolves to a path, null when they cancelled, or undefined when there is no dialog here.
+ */
+export function chooseFile({ platform = process.platform, run = execFile } = {}) {
+  const [cmd, args] = chooserFor(platform);
+  return new Promise((resolve) => {
+    run(cmd, args, { timeout: 10 * 60_000, windowsHide: false }, (err, stdout) => {
+      const picked = String(stdout ?? '').trim();
+      if (picked) return resolve(picked);
+      // The program could not start (ENOENT, EACCES: a string code) means no
+      // dialog here; a non-zero exit from one that ran is a cancel.
+      resolve(typeof err?.code === 'string' ? undefined : null);
+    });
+  });
+}
+
+/** Files under `root` for the fallback picker, nearest first, at most `limit`. */
+export async function projectFiles(root, limit = 200) {
+  const found = [];
+  const queue = [''];
+  while (queue.length && found.length < limit) {
+    const dir = queue.shift();
+    const entries = await fs.readdir(path.join(root, dir), { withFileTypes: true }).catch(() => []);
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const rel = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP.has(e.name) && !e.name.startsWith('.')) queue.push(rel); }
+      else if (e.isFile() && found.length < limit) found.push(rel);
+    }
+  }
+  return found;
+}
+
+/**
+ * Read chosen files into what a request carries.
+ * Returns { images: [dataUrl], text: string to append to the request, notes: [line for the user] }.
+ */
+export async function loadAttachments(files) {
+  const images = [];
+  const blocks = [];
+  const notes = [];
+
+  for (const file of files) {
+    const name = path.basename(file);
+    let buf;
+    try {
+      buf = await fs.readFile(file);
+    } catch {
+      notes.push(`could not read ${name} — skipped`);
+      continue;
+    }
+
+    const kind = IMAGE[path.extname(name).slice(1).toLowerCase()];
+    if (kind) {
+      if (buf.length > MAX_IMAGE_BYTES) { notes.push(`${name} is over 10 MB — skipped`); continue; }
+      images.push(`data:image/${kind};base64,${buf.toString('base64')}`);
+      notes.push(`attached ${name}`);
+      continue;
+    }
+
+    if (buf.subarray(0, 8192).includes(0)) {
+      notes.push(`${name} is not a picture or a text file — skipped`);
+      continue;
+    }
+    if (buf.length > MAX_TEXT_BYTES) { notes.push(`${name} is over 100 KB of text — skipped`); continue; }
+    const text = buf.toString('utf8').trimEnd();
+    // A fence longer than any run of backticks inside, so the file cannot close it early.
+    const fence = '`'.repeat(Math.max(3, ...(text.match(/`+/g) ?? []).map((run) => run.length + 1)));
+    blocks.push(`Reference file ${name}, attached by the user:\n${fence}\n${text}\n${fence}`);
+    notes.push(`attached ${name}`);
+  }
+
+  return { images, text: blocks.length ? `\n\n${blocks.join('\n\n')}` : '', notes };
+}

package/src/core/loop.js

@@ -51,6 +51,9 @@ import { StuckWatch, eventFor, describeHit } from './stuck.js';
 import { serversReadySince } from '../tools/shell.js';
 import { formatDuration } from '../ui/activity.js';
 import { MAX_FILE_OUTPUT } from '../tools/shared.js';
+import { openInBrowser } from './opener.js';
+import { withScope } from './scope.js';
+import { chooseFile, projectFiles, loadAttachments } from './attach.js';
 import { runDoctor } from './doctor.js';
 import { JS_LOGIC } from './jslogic.js';
 import { deploy } from '../tools/deploy.js';
@@ -110,19 +113,6 @@ const SILENT = new Set(['update_plan']);
 /** How many rounds of "the type check found errors, fix them" one turn may take. */
 const MAX_FIX_ROUNDS = 3;
 
-/**
- * Rides on a new app's request, the last thing the model reads. In the system
- * prompt and the skill alone, Flash-Lite still built "make me a tasks app" as a
- * tasks app plus pomodoro timer, kanban board and analytics — twice running.
- */
-const SCOPE_NOTE =
-  '(From ucode: if this asks for a new app, build it complete and well made, but as the one app asked ' +
-  'for - no extra views or tools such as timers, calendars, kanban boards, analytics, stats or an ' +
-  'editor for making your own, unless the request names them.)';
-
-/** A request that may be for a new app. Loose on purpose: the note it adds says "if". */
-const BUILD_ASK = /\b(?:make|build|create|design|code|write|generate|develop)\b|\bi\s+(?:want|need)\b|\b(?:app|game|website|site|page|tracker|calculator|quiz)\b/i;
-
 /** A file up to this many lines is sent whole on its first read, whatever slice was asked for. */
 const WHOLE_READ_LINES = 1500;
 
@@ -1032,6 +1022,7 @@ export class Agent {
         }
       };
       this.ui.onModeChange = () => this.showHeader({ clear: false });
+      this.ui.onAttach = () => { this.attachFile().catch(() => {}); };
     }
 
     for (const problem of this.skills.problems ?? []) {
@@ -1243,12 +1234,18 @@ export class Agent {
     forgetReviews(); // a new request: its apps get a fresh design review
     setRequest(input); // create_app checks this before choosing a starter
     const images = await this.attachImages(input);
+    // Files added with the "+ file" button: pictures go as pictures, text as reference.
+    const added = await loadAttachments(this.ui.takeAttachments?.() ?? []);
+    for (const line of added.notes) this.ui.note(line);
+    images.push(...added.images);
     // The skill goes in ahead of the request, so the request is the last
     // thing the model reads. After it, a page of house rules was what the
     // model answered: asked for a dark mode toggle on its second turn, a live
     // run re-read two files and repeated its first turn's summary instead.
     this.autoLoad(input);
-    const request = images.length ? { role: 'user', content: input, images } : { role: 'user', content: input };
+    const request = images.length
+      ? { role: 'user', content: input + added.text, images }
+      : { role: 'user', content: input + added.text };
     this.push(request);
 
     if (!this.session.title || this.session.title === 'Untitled') {
@@ -1262,7 +1259,7 @@ export class Agent {
     // Nothing to look up in an empty folder, so those tools do not go out with
     // the request. Decided per turn: the moment there is code, they are back.
     this.fresh = !hasCode(this.map);
-    if (this.fresh || BUILD_ASK.test(input)) request.content = `${input}\n\n${SCOPE_NOTE}`;
+    request.content = withScope(input, { fresh: this.fresh }) + added.text;
     this.wantsWeb = WANTS_WEB.test(input);
     await this.persist();
 
@@ -1796,25 +1793,30 @@ export class Agent {
   }
 
   /**
-   * Show a URL or a local page in the desktop browser. False when it did not.
-   *
-   * A file goes to explorer on Windows, not `cmd /c start`: the folder name
-   * comes from the model, and an & in it would be a second command to cmd.
+   * The "+ file" button: choose a file with the computer's own dialog — or,
+   * where there is none, from the project's files — to go with the next message.
    */
+  async attachFile() {
+    if (this.attaching) return; // a second click while the dialog is open
+    this.attaching = true;
+    try {
+      let file = await chooseFile();
+      if (file === undefined) {
+        const files = await projectFiles(this.cwd);
+        if (!files.length) { this.ui.note('no files in this folder to add'); return; }
+        const index = await this.ui.pick(files, { hint: 'enter to add · esc to cancel' });
+        file = Number.isInteger(index) ? path.join(this.cwd, files[index]) : null;
+      }
+      if (file) this.ui.addAttachment(path.resolve(this.cwd, file));
+    } finally {
+      this.attaching = false;
+    }
+  }
+
+  /** Show a URL or a page in the project in the desktop browser (see opener.js). UCODE_OPEN=0 turns it off. */
   openInBrowser(target) {
     if (!this.full || process.env.UCODE_OPEN === '0') return false;
-    const web = /^https?:\/\//.test(target);
-    // Only pages inside the project: a UNC path would have explorer reach out to another machine.
-    const rel = web ? '' : path.relative(this.cwd, target);
-    if (!web && (!rel || rel.startsWith('..') || path.isAbsolute(rel))) return false;
-    const [cmd, args] = process.platform === 'win32'
-      ? (web ? ['cmd', ['/c', 'start', '', target]] : ['explorer.exe', [target]])
-      : [process.platform === 'darwin' ? 'open' : 'xdg-open', [target]];
-    try {
-      // A missing opener (no xdg-open) fails later, as an event; unheard, it would crash ucode.
-      spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true }).on('error', () => {}).unref();
-      return true;
-    } catch { return false; /* no browser to open — the link is in the answer */ }
+    return openInBrowser(target, { root: this.cwd });
   }
 
   cmdStats() {
@@ -3032,7 +3034,7 @@ ${out.content}` });
     }
     this.ui.blank();
     this.ui.write(dim('  /models, /session and /sessions do the same as /model and /resume.'));
-    this.ui.write(dim('  ctrl+b swaps plan and build · esc stops a running turn · ctrl+d quits'));
+    this.ui.write(dim('  ctrl+b swaps plan and build · + file (or ctrl+o) adds a picture or file · esc stops a running turn · ctrl+d quits'));
     this.ui.blank();
   }
 

package/src/core/opener.js

@@ -0,0 +1,44 @@
+/**
+ * opener.js — showing a finished page or a running server in the user's own
+ * browser.
+ *
+ * Kept apart from the loop because it is the one place ucode starts a program
+ * on a path the model chose, and that deserves to be read on its own.
+ */
+
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+/** Is this a web address rather than a file on disk? */
+const isWeb = (target) => /^https?:\/\//.test(target);
+
+/**
+ * Only pages inside the project are opened. A folder name comes from the
+ * model, and a UNC path (\\host\share) would have explorer reach out to
+ * another machine.
+ */
+export function insideRoot(target, root) {
+  const rel = path.relative(root, target);
+  return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+/**
+ * Open a URL or a page inside `root`. Returns whether an opener was started.
+ *
+ * A file goes to explorer on Windows, not `cmd /c start`: an & in a folder
+ * name would be a second command to cmd.
+ */
+export function openInBrowser(target, { root }) {
+  const web = isWeb(target);
+  if (!web && !insideRoot(target, root)) return false;
+  const [cmd, args] = process.platform === 'win32'
+    ? (web ? ['cmd', ['/c', 'start', '', target]] : ['explorer.exe', [target]])
+    : [process.platform === 'darwin' ? 'open' : 'xdg-open', [target]];
+  try {
+    // A missing opener (no xdg-open) fails later, as an event; unheard, it would crash ucode.
+    spawn(cmd, args, { stdio: 'ignore', detached: true, windowsHide: true }).on('error', () => {}).unref();
+    return true;
+  } catch {
+    return false; // no browser to open — the link is in the answer
+  }
+}

package/src/core/scope.js

@@ -0,0 +1,23 @@
+/**
+ * scope.js — keeping a new app to what was asked for.
+ *
+ * In the system prompt and the build-app skill alone, Flash-Lite still built
+ * "make me a tasks app" as a tasks app plus a pomodoro timer, a kanban board
+ * and analytics — twice running — and the extra views were where the builds
+ * broke. So the rule also rides on the request itself, the last thing the
+ * model reads before it starts.
+ */
+
+export const SCOPE_NOTE =
+  '(From ucode: if this asks for a new app, build it complete and well made, but as the one app asked ' +
+  'for - no extra views or tools such as timers, calendars, kanban boards, analytics, stats or an ' +
+  'editor for making your own, unless the request names them.)';
+
+/** A request that may be for a new app. Loose on purpose: the note it adds says "if". */
+export const BUILD_ASK =
+  /\b(?:make|build|create|design|code|write|generate|develop)\b|\bi\s+(?:want|need)\b|\b(?:app|game|website|site|page|tracker|calculator|quiz)\b/i;
+
+/** The request as the model sees it: one in an empty folder, or shaped like a build, carries the note. */
+export function withScope(input, { fresh = false } = {}) {
+  return fresh || BUILD_ASK.test(input) ? `${input}\n\n${SCOPE_NOTE}` : input;
+}

package/src/tools/browser.js

@@ -232,6 +232,63 @@ const NOT_ADD = /search|filter|find|sort|query/i;
 const LIST_HINT = /task|todo|to-do|item|note|add|new|entry|expense|habit|title|what needs|remind/i;
 const ADD_BUTTON = /^\s*(?:\+|add|new|create|save|submit|post|done)\b|\b(?:add|create|save)\s/i;
 
+/** A value a form will take for a field of this type, or null to leave the field alone. */
+function sampleFor(type, today) {
+  switch (type) {
+    case 'number': return '42';
+    case 'date': return today;
+    case 'time': return '12:00';
+    case 'datetime-local': return `${today}T12:00`;
+    case 'month': return today.slice(0, 7);
+    case 'email': return 'check@example.com';
+    case 'url': return 'https://example.com';
+    case 'tel': return '5550100';
+    case 'text': case 'textarea': case 'search': case '': return PROBE_TEXT;
+    default: return null; // checkboxes, radios, files, colours: nothing to guess
+  }
+}
+
+/**
+ * Fill in the rest of the form the probe text went into, the way a person
+ * would before pressing Add.
+ *
+ * Traced: a budget tracker's form also needs an amount. Only the description
+ * was typed, the browser refused the submit, and a working app was reported as
+ * "ADDING DOES NOT WORK" — the model then spent its fix rounds on code that
+ * worked. Filled: required fields, empty number fields (amounts are often
+ * checked in script, not marked required) and dropdowns left on a blank choice.
+ */
+async function fillTheRest(page, field) {
+  const marked = await field.evaluate((e) => {
+    if (!e.form) return false;
+    e.form.setAttribute('data-ucode-probe', '');
+    return true;
+  }).catch(() => false);
+  if (!marked) return;
+
+  const today = new Date().toISOString().slice(0, 10);
+  const all = page.locator('form[data-ucode-probe] :is(input, select, textarea)');
+  const n = Math.min(await all.count().catch(() => 0), 20);
+  for (let i = 0; i < n; i++) {
+    const el = all.nth(i);
+    const info = await el.evaluate((e) => ({
+      tag: e.tagName.toLowerCase(),
+      type: (e.getAttribute('type') || (e.tagName === 'TEXTAREA' ? 'textarea' : '')).toLowerCase(),
+      empty: !e.value,
+      required: e.required,
+    })).catch(() => null);
+    if (!info?.empty || !(await el.isVisible().catch(() => false))) continue;
+    if (info.tag === 'select') {
+      await el.selectOption({ index: 1 }, { timeout: 2_000 }).catch(() => {});
+      continue;
+    }
+    if (!info.required && info.type !== 'number') continue;
+    const value = sampleFor(info.type, today);
+    if (value !== null) await el.fill(value, { timeout: 2_000 }).catch(() => {});
+  }
+  await page.locator('form[data-ucode-probe]').evaluate((f) => f.removeAttribute('data-ucode-probe')).catch(() => {});
+}
+
 async function tryAdd(page) {
   const shows = () => page.evaluate((t) => document.body.innerText.includes(t), PROBE_TEXT).catch(() => false);
   const settle = () => page.waitForTimeout(400);
@@ -279,6 +336,7 @@ async function tryAdd(page) {
   }
   const ok = await field.el.fill(PROBE_TEXT, { timeout: 2_000 }).then(() => true).catch(() => false);
   if (!ok) return tried.length ? { tried, added: false, listApp } : null;
+  await fillTheRest(page, field.el);
   await field.el.press('Enter', { timeout: 2_000 }).catch(() => {});
   await settle();
   tried.push(`typed "${PROBE_TEXT}" into ${field.hint ? `"${field.hint.slice(0, 30)}"` : 'the field'} and pressed Enter`);

package/src/tools/scaffold.js

@@ -67,6 +67,24 @@ export function normaliseFiles(files) {
   });
 }
 
+/**
+ * Every file passed to create_app belongs in the app's folder.
+ *
+ * Traced: a build from a sketch passed "index.html", "style.css" and
+ * "main.js" with no folder. They landed beside the app, the folder kept the
+ * blank starter, and nothing was checked or handed over. A path already under
+ * the folder, absolute, or reaching out with .. is left as it was.
+ */
+export function intoFolder(files, folder) {
+  const prefix = `${folder}/`;
+  return files.map((f) => {
+    if (!f || typeof f.path !== 'string') return f;
+    const p = path.posix.normalize(f.path.replace(/\\/g, '/'));
+    if (path.isAbsolute(p) || p.startsWith('..') || p.startsWith(prefix)) return f;
+    return { ...f, path: prefix + p };
+  });
+}
+
 /** What each starter is for, so the choice is made on purpose. */
 export const TEMPLATE_NOTES = {
   'next-shadcn': 'Next.js, TypeScript, Tailwind and shadcn/ui. For anything with routes, data or many components.',
@@ -431,7 +449,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // The app's own files, written in this same call. Two round trips become
   // one, and round trips are nearly all of the time a build takes.
   // Next.js only: paths that have missed src/ are corrected before they land.
-  const placed = template === 'next-shadcn' ? placeForNext(given, path.basename(target.abs)) : { files: given, moved: [] };
+  const inFolder = intoFolder(given, target.show);
+  const placed = template === 'next-shadcn' ? placeForNext(inFolder, path.basename(target.abs)) : { files: inFolder, moved: [] };
   const mine = placed.files;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
   const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));

package/src/ui/screen.js

@@ -40,7 +40,7 @@ import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
   shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine, planRows, tidyReply, trimAnswer,
-  bannerPaint, RAIL, modeChip, asNarrationLine } from './theme.js';
+  bannerPaint, RAIL, modeChip, ADD_CHIP, asNarrationLine } from './theme.js';
 import { FRAME_MS, spinnerGlyph, formatDuration, doneLine, workingLine, bannerSweep, SWEEP_MS } from './activity.js';
 import { gitBranch } from '../core/git.js';
 import { renderer, render } from './markdown.js';
@@ -209,6 +209,12 @@ export class Screen {
     // the chip is clickable wherever the terminal forwards clicks.
     this.mode = 'build';
     this.chipTo = 0;
+    // The "+ file" button: its columns on the status row, and the files it has
+    // added so far, which go with the next message. Ctrl+O does the same.
+    this.plusFrom = 0;
+    this.plusTo = 0;
+    this.attachments = [];
+    this.onAttach = null;
     this.onInterrupt = null;
     this.onModeChange = null;
     this.spinTimer = null;
@@ -802,7 +808,7 @@ export class Screen {
       ['dir', value(shortenPath(this.facts.cwd ?? this.cwd, room - 10))],
       branch && ['branch', value(branch)],
       VERSION && ['version', value(this.facts.update ? `${VERSION} → ${this.facts.update} next start` : VERSION)],
-      ['keys', value('/help · esc interrupts · ctrl+b plan')],
+      ['keys', value('/help · esc interrupts · ctrl+b plan · ctrl+o file')],
     ].filter(Boolean).slice(0, BANNER.length - 1);
 
     while (facts.length < BANNER.length - 1) facts.push(['', '']);
@@ -980,7 +986,7 @@ export class Screen {
   statusRow(width = this.width()) {
     const inner = width - 2;             // the space between the two borders
     const chip = this.modeChip();
-    const left = ` ${chip}  ${chalk.white(this.model || '—')}`;
+    const left = ` ${chip}  ${ADD_CHIP}  ${chalk.white(this.model || '—')}`;
 
     // How long the turn has taken, back in the box beside the other two facts
     // about the session. It is not on the live line: that line says what is
@@ -993,9 +999,13 @@ export class Screen {
 
     // Where a click on the bottom row still counts as hitting the mode chip.
     this.chipTo = 2 + visLen(chip);
+    this.plusFrom = this.chipTo + 3;                     // after the two spaces
+    this.plusTo = this.plusFrom + visLen(ADD_CHIP) - 1;
 
     const between = Math.max(1, inner - visLen(left) - visLen(right));
-    const middle = this.flashText ? dim(clip(this.flashText, between - 2)) : '';
+    const files = this.attachments.map((f) => path.basename(f)).join(', ');
+    const middle = this.flashText ? dim(clip(this.flashText, between - 2))
+      : files ? sky(clip(`+ ${files}`, between - 2)) : '';
 
     const tail = middle ? `${middle}   ` : '';
     const pad = Math.max(1, inner - visLen(left) - visLen(tail) - visLen(right));
@@ -1417,11 +1427,29 @@ export class Screen {
     if (this.welcoming()) {
       const g = this.welcomeGeometry();
       const statusRow = g.boxTop + g.inputRows + 3;          // 1-based
-      if (row === statusRow && col > g.left + 1 && col <= g.left + this.chipTo) this.toggleMode();
+      if (row !== statusRow) return;
+      if (col > g.left + 1 && col <= g.left + this.chipTo) this.toggleMode();
+      else if (col >= g.left + this.plusFrom && col <= g.left + this.plusTo) this.onAttach?.();
       return;
     }
-    // The mode chip, at the left of the bottom row.
-    if (row === this.rows - 1 && col >= 2 && col <= this.chipTo) this.toggleMode();
+    // The mode chip and the "+ file" button, at the left of the bottom row.
+    if (row !== this.rows - 1) return;
+    if (col >= 2 && col <= this.chipTo) this.toggleMode();
+    else if (col >= this.plusFrom && col <= this.plusTo) this.onAttach?.();
+  }
+
+  /** A file chosen with "+ file", to go with the next message. */
+  addAttachment(file) {
+    if (!this.attachments.includes(file)) this.attachments.push(file);
+    this.render();
+  }
+
+  /** The files for the message being sent; the button starts empty again. */
+  takeAttachments() {
+    const files = this.attachments;
+    this.attachments = [];
+    this.render();
+    return files;
   }
 
   onKey(key) {
@@ -1453,7 +1481,10 @@ export class Screen {
           this.history.unshift(text);
           // Answers to a y/N or a numbered pick are not messages, so they are
           // not echoed: the prompt reports its own outcome.
-          if (!this.pendingPrompt) this.userMessage(text);
+          if (!this.pendingPrompt) {
+            this.userMessage(text);
+            for (const f of this.attachments) this.push(dim(`  + ${path.basename(f)}`));
+          }
         }
         this.render();
         this.submit(text);
@@ -1481,7 +1512,12 @@ export class Screen {
         this.toggleMode();
         return;
 
-      case '\x15':  // ctrl+u — clear the line
+      case '\x0f':  // ctrl+o — the "+ file" button, for terminals that send no clicks
+        this.onAttach?.();
+        return;
+
+      case '\x15':  // ctrl+u — clear the line; on an empty line, the attached files
+        if (!this.buffer) this.attachments = [];
         this.buffer = this.buffer.slice(this.cursor);
         this.cursor = 0;
         break;

package/src/ui/theme.js

@@ -127,6 +127,9 @@ export const PLAN_CHIP = chalk.bgHex('#24344f').hex('#8fbcff').bold;
 export const modeChip = (mode) =>
   mode === 'plan' ? PLAN_CHIP(' PLAN ') : BUILD_CHIP(' BUILD ');
 
+/** The "+ file" button beside the mode chip, in the quieter of the two chip styles. */
+export const ADD_CHIP = PLAN_CHIP(' + file ');
+
 /** The spinner. Braille dots, because they animate in place without jitter. */
 export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];