ucode-agent 1.35.0 → 1.37.0

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.29.0
+                                                                           v1.36.0
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box
@@ -107,12 +107,14 @@ of what ucode is asked to do, and it answers far sooner than the big reasoning
 models. Switch to Ultra when a problem needs the million-token window more than
 the speed.
 
-**A busy model never stops a build.** Free endpoints are shared, and "too many
-requests" is routine. ucode waits it out with growing pauses, and if the model
-stays busy it carries on with the next one — North Mini Code, then Nemotron 3.5
-Lightning, Super, Ultra — from exactly where it was, and tells you it switched.
-If every model is busy at once it waits a minute and goes round again. Your
-chosen model gets another go a few minutes later.
+**The model you chose is the model you keep.** Free endpoints are shared and
+"too many requests" is routine, so ucode waits it out with growing pauses and
+comes back to the same model. It does not quietly hand your build to a
+different one: a build that starts on one model and finishes on another
+finishes to a different standard, and the swap lands exactly when you are least
+placed to work out why the output changed. Set `UCODE_FALLBACK=1` if you would
+rather it moved down the list — North Mini Code, Nemotron 3.5 Lightning, Super,
+Ultra — when a model stays busy.
 
 ## What it does
 
@@ -211,6 +213,13 @@ same link. Needs a token from vercel.com/account/tokens in `~/.ucode/.env` as
 sunset, graphite, violet or citrus — each a full light and dark palette with its
 own font, so apps stop looking like the same default blue.
 
+**Every turn can be taken back.** `/undo` puts back every file the last turn
+changed — a rewritten file returns byte for byte, a file that did not exist
+before is removed again. Each write keeps the original the first time that turn
+touches it, so what comes back is the state before the turn rather than before
+the last of six edits to the same file. An agent that writes to your disk on
+its own should be able to take it back, whether or not the project has git.
+
 **It notices when it is going round in circles.** The same failing edit, an edit
 that changes nothing, or a build failing on the same errors three times gets a
 firm, specific note; if that does not work, the turn moves to another model.
@@ -238,13 +247,23 @@ written, its install starts in the background while the rest of the app is
 still being written. An install the model asks for later waits for that one
 instead of running twice, and anything run in that folder waits for it too.
 
-**It looks at what it built.** `look_at_app` opens the running app in a real
-browser — the Edge or Chrome already on your machine, so there is nothing extra
-to download — at 375px and 1440px. It reports console errors, failed requests,
-content that spills off a phone screen, broken images and unlabeled controls,
-saves screenshots to `.ucode/screenshots`, and has Nemotron Nano Omni review them
-the way a designer would. The model fixes what it finds before calling the app
-done. Both widths load at once, and the designer review — the slow part — runs
+**It opens what it built and uses it.** Every app build ends with a look — not
+when the model remembers to ask for one, but as part of the same pass that
+type-checks. It opens the app in a real browser (the Edge or Chrome already on
+your machine, so there is nothing extra to download) at 375px and 1440px, and
+serves the folder itself when there is no dev server to point at, which is how
+a three-file app gets checked at all.
+
+Then it uses the app. It types into the first field, presses Enter, and clicks
+the button that submits — and if the page gains no elements, changes no text
+and stores nothing, that is reported as the thing to fix before anything else.
+A page that renders and has no working behaviour passes a type check, a syntax
+check and a screenshot; the only way to find out is to press something.
+
+It also reports console errors, failed requests, content that spills off a
+phone screen, broken images and unlabeled controls, saves screenshots to
+`.ucode/screenshots`, and has Nemotron Nano Omni review them the way a designer
+would. The model fixes what it finds before calling the app done. Both widths load at once, and the designer review — the slow part — runs
 on the first look at an app in each request and is skipped, not waited on, when
 the vision model is busy. The look after the fixes re-runs only the fast checks:
 a few seconds.
@@ -355,6 +374,11 @@ Everything after the frontmatter is the instruction.
 | `/session delete 2,5` | delete saved conversations by number (or `d d` in the list) |
 | `/new` | save this one and start fresh |
 | `/remember <note>` | add a standing note to this project's `UCODE.md` |
+| `/undo` | put back every file the last turn changed |
+| `/look [url]` | open the running app and report what is on the page |
+| `/deploy [folder]` | put the app online and get its link |
+| `/stats` | time, steps and tokens this session |
+| `/doctor` | check that everything ucode needs is working |
 | `/skills` | what it knows how to do, and what is loaded |
 | `/search <query>` | look something up on the web |
 | `/copy` | last reply to the clipboard |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.35.0",
+  "version": "1.37.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/loop.js

@@ -19,6 +19,7 @@ import { testRunnerFor, relatedCommand, summariseFailures } from './tests.js';
 import { LogWatch } from './livelog.js';
 import { checkHtml } from './htmlcheck.js';
 import { runningServers } from '../tools/shell.js';
+import { beginTurn, undoTurn, changedCount } from './undo.js';
 import { spawn } from 'node:child_process';
 
 import {
@@ -1076,6 +1077,10 @@ export class Agent {
   }
 
   async turn(input) {
+    // From here every file this turn writes keeps a copy of how it was, so
+    // /undo can put the whole turn back.
+    beginTurn();
+    this.lookedThisTurn = false;
     forgetReviews(); // a new request: its apps get a fresh design review
     const images = await this.attachImages(input);
     this.push(images.length
@@ -1642,6 +1647,14 @@ export class Agent {
     // are still built by the tool — the model reads them in the result — they
     // simply do not go on screen.
     if (out.diff?.length) this.ui.diffStat?.(countDiff(out.diff));
+    // A look is the most thorough thing ucode runs — two widths, screenshots,
+    // a designer's review, and now the app actually driven — and it was the
+    // quietest line on screen, saying only that it had happened. Its verdict
+    // goes on the same line, the way a change carries its two numbers.
+    if (call.name === 'look_at_app') {
+      const found = /^(\d+) problem/.exec(out.summary ?? '');
+      this.ui.runStat?.(found ? `${found[1]} to fix` : 'clean');
+    }
     this.push({ role: 'tool', toolCallId: call.id, name: call.name, content: out.content + this.stuckNote(call, { out }) });
   }
 
@@ -1978,9 +1991,59 @@ export class Agent {
     const live = await this.liveErrors();
     if (live) problems.push(live);
 
+    // Then look at it, in the same pass that type-checks — not when the model
+    // remembers to. A check that runs only when it is asked for reports
+    // nothing on exactly the builds that needed it, and this is the only one
+    // that opens the page, presses its buttons and finds out whether any of it
+    // actually works.
+    if (!problems.length) {
+      const seen = await this.lookOnceThisTurn(root, changed);
+      if (seen) problems.push(seen);
+    }
+
     return problems.length ? problems.join('\n\n') : null;
   }
 
+  /**
+   * Open what was just built and report what is wrong with it, once a turn.
+   *
+   * Points at a dev server when one is running; otherwise serves the folder
+   * holding the page that changed, which is the only way the default
+   * three-file starter gets looked at at all — it has no server to point at.
+   * Only for a turn that touched something with a page in it: there is nothing
+   * to open after a change to a utility module.
+   *
+   * Never throws. A browser that will not start is a reason to skip the look,
+   * never a reason to fail the turn that built the app.
+   */
+  async lookOnceThisTurn(root, changed) {
+    if (this.lookedThisTurn) return null;
+
+    const pages = [...changed].filter((f) => /\.(?:html?|tsx|jsx)$/i.test(f));
+    if (!pages.length) return null;
+    this.lookedThisTurn = true;
+
+    try {
+      const { lookAtApp, withStaticServer } = await import('../tools/browser.js');
+      const look = async (url) => {
+        this.ui.toolCall(`Looking at ${url} on a phone and a desktop`);
+        const out = await lookAtApp({ url });
+        const found = /^(\d+) problem/.exec(out.summary ?? '');
+        this.ui.runStat?.(found ? `${found[1]} to fix` : 'clean');
+        return found ? `I opened the app and looked at it:\n\n${out.content}` : null;
+      };
+
+      const server = runningServers().at(-1);
+      if (server?.url) return await look(server.url);
+
+      const html = pages.find((f) => /\.html?$/i.test(f));
+      if (!html) return null;
+      return await withStaticServer(path.dirname(path.resolve(root, html)), look);
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Anything the running app has complained about since the last look. A dev
    * server knows about a broken import the moment it happens; without this
@@ -2145,6 +2208,7 @@ export class Agent {
       case '/search':   return this.cmdSearch(arg);
       case '/copy':     return this.cmdCopy();
       case '/stats':    return this.cmdStats();
+      case '/undo':     return this.cmdUndo();
       case '/doctor':   return this.cmdDoctor();
       case '/look':     return this.cmdLook(arg);
       case '/deploy':   return this.cmdDeploy(arg);
@@ -2187,9 +2251,33 @@ ${out.content}` });
     }
   }
 
+  /**
+   * Put every file the last turn wrote back the way it was.
+   *
+   * The one thing an agent that edits your files on its own has to have. It
+   * covers the last turn only — the state you want back is almost always the
+   * one that just happened — and it says how many files it touched rather than
+   * listing them, the way everything else here reports work.
+   */
+  async cmdUndo() {
+    const count = changedCount();
+    if (!count) {
+      this.ui.note('nothing to undo — the last turn changed no files.');
+      return;
+    }
+
+    const { restored, removed, failed } = await undoTurn();
+    const parts = [];
+    if (restored.length) parts.push(`${restored.length} file${restored.length === 1 ? '' : 's'} put back`);
+    if (removed.length) parts.push(`${removed.length} removed`);
+    this.ui.write(`  ${theme.ok('✓')} ${parts.join(', ') || 'nothing to do'}`);
+    for (const f of failed) this.ui.write(theme.error(`  could not undo ${f}`));
+  }
+
   cmdHelp() {
     const rows = [
       ['/help', 'this list'],
+      ['/undo', 'put back every file the last turn changed'],
       ['/stats', 'time, steps and tokens this session'],
       ['/doctor', 'check that everything ucode needs is working'],
       ['/look [url]', 'open the running app and report what is on the page'],

package/src/core/undo.js

@@ -0,0 +1,81 @@
+/**
+ * undo.js — what every file looked like before this turn touched it.
+ *
+ * ucode edits files on its own. Until now there was no way back from that: a
+ * turn that went wrong left the work in whatever state it reached, and the
+ * only recovery was git, if the project had git and the user had committed.
+ * An agent that writes to your disk without an undo is asking for a kind of
+ * trust it has not earned.
+ *
+ * So the original of every file is kept the first time a turn writes to it —
+ * the first time only, because the point of an undo is the state before the
+ * turn, not before the last of six edits to the same file. A file that did not
+ * exist is remembered as absent, and undoing removes it again.
+ *
+ * Kept in memory, for one turn. Persisting it would be a different feature
+ * with a different set of questions (how many turns, where, how big), and the
+ * turn you want back is almost always the one that just happened.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/** abs path -> the contents before this turn, or null when it did not exist. */
+let before = new Map();
+let armed = false;
+
+/** A new turn: nothing remembered yet, and from here on writes are recorded. */
+export function beginTurn() {
+  before = new Map();
+  armed = true;
+}
+
+/**
+ * Remember a file as it is now, if this turn has not already seen it.
+ *
+ * Reading before every write costs one stat and one read on files that are
+ * about to be rewritten anyway. Never throws: failing to record an undo is a
+ * reason to have no undo, never a reason to fail the write.
+ */
+export async function remember(abs) {
+  if (!armed || before.has(abs)) return;
+  try {
+    before.set(abs, await fs.readFile(abs, 'utf8'));
+  } catch {
+    before.set(abs, null); // did not exist, so undoing means deleting it
+  }
+}
+
+/** How many files this turn has changed so far. */
+export function changedCount() {
+  return before.size;
+}
+
+/**
+ * Put every file back the way it was, and say what was done.
+ *
+ * Returns { restored, removed, failed } rather than throwing, because a
+ * partial undo is still worth reporting: knowing four of five files went back
+ * is the difference between fixing one thing by hand and wondering.
+ */
+export async function undoTurn() {
+  const out = { restored: [], removed: [], failed: [] };
+
+  for (const [abs, text] of before) {
+    try {
+      if (text === null) {
+        await fs.rm(abs, { force: true });
+        out.removed.push(abs);
+      } else {
+        await fs.mkdir(path.dirname(abs), { recursive: true }).catch(() => {});
+        await fs.writeFile(abs, text, 'utf8');
+        out.restored.push(abs);
+      }
+    } catch (err) {
+      out.failed.push(`${abs}: ${err.message}`);
+    }
+  }
+
+  before = new Map();
+  return out;
+}

package/src/tools/browser.js

@@ -14,6 +14,7 @@
  */
 
 import { promises as fs } from 'node:fs';
+import fsSync from 'node:fs';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
 import { ask } from '../core/provider.js';
@@ -271,6 +272,42 @@ async function useTheApp(page) {
   return { tried, worked: moved(before, after) };
 }
 
+/**
+ * Serve a folder over http just long enough to look at it.
+ *
+ * The default starter has no dev server — three files that open straight from
+ * disk — so there was nothing for the checker to point at, and the most
+ * thorough thing ucode runs could not run on the apps it makes most often. A
+ * static server on an ephemeral port costs nothing and closes again the
+ * moment the look is done.
+ */
+export async function withStaticServer(dir, fn) {
+  const http = await import('node:http');
+  const root = path.resolve(dir);
+  const types = {
+    '.html': 'text/html', '.css': 'text/css', '.js': 'text/javascript',
+    '.json': 'application/json', '.svg': 'image/svg+xml', '.png': 'image/png',
+  };
+
+  const server = http.createServer((req, res) => {
+    const rel = (req.url === '/' ? '/index.html' : req.url).split('?')[0];
+    const file = path.join(root, decodeURIComponent(rel));
+    if (!file.startsWith(root)) { res.writeHead(403); res.end(); return; }
+    fsSync.readFile(file, (err, buf) => {
+      if (err) { res.writeHead(404); res.end('not found'); return; }
+      res.writeHead(200, { 'content-type': types[path.extname(file).toLowerCase()] ?? 'text/plain' });
+      res.end(buf);
+    });
+  });
+
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  try {
+    return await fn(`http://127.0.0.1:${server.address().port}`);
+  } finally {
+    server.close();
+  }
+}
+
 export async function lookAtApp({ url, paths = ['/'] }) {
   const base = String(url ?? '').trim().replace(/\/+$/, '');
   if (!LOCAL.test(`${base}/`)) {

package/src/tools/files.js

@@ -8,6 +8,7 @@
  */
 
 import { promises as fs } from 'node:fs';
+import { remember } from '../core/undo.js';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
 import {
@@ -297,6 +298,7 @@ async function put(target, content, { diffMax = 16 } = {}) {
 
   try {
     await fs.mkdir(path.dirname(target.abs), { recursive: true });
+    await remember(target.abs);
     await fs.writeFile(target.abs, content, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -452,12 +454,13 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
       fix: 'edit_file replaces existing text. Use write_file to create a file.',
     });
   }
+  // An edit whose two halves are the same asks for the file to stay as it is,
+  // which it will. Refusing that was a hard failure, and the model answered it
+  // by sending the same edit again — the stuck detector carries a special case
+  // for exactly this loop. Saying "already done" ends it in one step.
   if (old_string === new_string) {
-    throw new ToolFailure({
-      kind: 'bad_args', attempted,
-      failed: `${prefix}old_string and new_string are identical, so the edit would change nothing.`,
-      fix: 'Set new_string to the text you actually want there.',
-    });
+    const found = text.indexOf(old_string);
+    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, loose: false };
   }
 
   // Models write \n. A file checked out on Windows is often \r\n, and then an
@@ -555,6 +558,7 @@ export async function editFile({ path: p, old_string, new_string }) {
   });
 
   try {
+    await remember(target.abs);
     await fs.writeFile(target.abs, text, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -628,6 +632,7 @@ export async function multiEdit({ path: p, edits }) {
   }
 
   try {
+    await remember(target.abs);
     await fs.writeFile(target.abs, text, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -716,7 +721,8 @@ export async function editFiles({ files }) {
 
   for (const { target, text } of planned) {
     try {
-      await fs.writeFile(target.abs, text, 'utf8');
+      await remember(target.abs);
+    await fs.writeFile(target.abs, text, 'utf8');
     } catch (err) {
       throw fsFailure(err, `editing ${target.show}`, target.show);
     }

package/src/tools/scaffold.js

@@ -108,88 +108,88 @@ async function copyTree(from, to, fill) {
  * globals.css and layout.tsx. Apps stop looking like the same default blue.
  * Returns the preset used, or null when the starter has none.
  */
-/**
- * The file in each starter that carries the design, not just some of the rules.
- *
- * next-shadcn has globals.css, which applyDesign re-tints. plain-html has one
- * stylesheet and it is the whole design system: the palette, a spacing scale,
- * radii, motion timings, focus rings, a reduced-motion rule and a breakpoint.
- */
-const TOKEN_FILE = { 'plain-html': 'styles.css' };
-
-/**
- * Put the starter's token block back when the app wrote over it without one.
- *
- * The stylesheet in plain-html is a design, not a placeholder — but `files`
- * lands straight on top of the starter, so a model passing its own styles.css
- * replaces the scale, the palette and the timings with whatever it typed. What
- * comes back is hand-rolled CSS with no system behind it, and an app built on
- * raw pixel values has uneven spacing everywhere for the rest of its life.
- *
- * A replacement that declares its own custom properties is left alone: that is
- * a model doing the job properly, and second-guessing it would be worse. Only
- * a stylesheet with no :root variables at all gets the starter's block put
- * back above it, where every rule underneath can reach it.
- */
-const ASSET_REF = /\b(href|src)=("|')(?!https?:|\/\/|\/|data:|#|mailto:|tel:)([^"']+)\2/g;
-
-/**
- * Take the app's own folder back out of its own links.
- *
- * create_app wants paths relative to the project root — "todo/index.html" —
- * because that is where every other file tool works from. The model then
- * carries the same prefix into the markup and writes
- * <link href="todo/styles.css"> inside todo/index.html, where it resolves to
- * todo/todo/styles.css and 404s. The page comes up as bare markup with no
- * stylesheet and no script: no design, no behaviour, nothing in the console
- * but two failed requests.
- *
- * It is the tool's own convention leaking into the file, so the tool takes it
- * back out. Only a leading "<folder>/" on a relative reference, which inside
- * that folder is always wrong — absolute paths, URLs, data: and anchors are
- * left exactly as they are.
- */
-async function unprefixOwnFolder(appDir, written) {
-  const prefix = `${path.basename(appDir)}/`;
-  const fixed = [];
-
-  for (const abs of written) {
-    if (!/\.html?$/i.test(abs)) continue;
-    const text = await fs.readFile(abs, 'utf8').catch(() => null);
-    if (text === null) continue;
-
-    let hits = 0;
-    const next = text.replace(ASSET_REF, (all, attr, quote, value) => {
-      if (!value.startsWith(prefix)) return all;
-      hits++;
-      return `${attr}=${quote}${value.slice(prefix.length)}${quote}`;
-    });
-
-    if (hits) {
-      await fs.writeFile(abs, next, 'utf8');
-      fixed.push(`${path.relative(appDir, abs).split(path.sep).join('/')} (${hits})`);
-    }
-  }
-  return fixed;
-}
-
-async function keepDesignTokens(appDir, template, written, starterCss) {
-  const rel = TOKEN_FILE[template];
-  if (!rel || !starterCss) return null;
-
-  const abs = path.join(appDir, rel);
-  if (!written.has(abs)) return null;                 // never overwritten
-
-  const now = await fs.readFile(abs, 'utf8').catch(() => null);
-  if (now === null || /:root\s*\{[^}]*--/.test(now)) return null;
-
-  const block = /:root\s*\{[\s\S]*?\n\}/.exec(starterCss);
-  if (!block) return null;
-
-  await fs.writeFile(abs, `${block[0]}\n\n${now}`, 'utf8');
-  return rel;
-}
-
+/**
+ * The file in each starter that carries the design, not just some of the rules.
+ *
+ * next-shadcn has globals.css, which applyDesign re-tints. plain-html has one
+ * stylesheet and it is the whole design system: the palette, a spacing scale,
+ * radii, motion timings, focus rings, a reduced-motion rule and a breakpoint.
+ */
+const TOKEN_FILE = { 'plain-html': 'styles.css' };
+
+/**
+ * Put the starter's token block back when the app wrote over it without one.
+ *
+ * The stylesheet in plain-html is a design, not a placeholder — but `files`
+ * lands straight on top of the starter, so a model passing its own styles.css
+ * replaces the scale, the palette and the timings with whatever it typed. What
+ * comes back is hand-rolled CSS with no system behind it, and an app built on
+ * raw pixel values has uneven spacing everywhere for the rest of its life.
+ *
+ * A replacement that declares its own custom properties is left alone: that is
+ * a model doing the job properly, and second-guessing it would be worse. Only
+ * a stylesheet with no :root variables at all gets the starter's block put
+ * back above it, where every rule underneath can reach it.
+ */
+const ASSET_REF = /\b(href|src)=("|')(?!https?:|\/\/|\/|data:|#|mailto:|tel:)([^"']+)\2/g;
+
+/**
+ * Take the app's own folder back out of its own links.
+ *
+ * create_app wants paths relative to the project root — "todo/index.html" —
+ * because that is where every other file tool works from. The model then
+ * carries the same prefix into the markup and writes
+ * <link href="todo/styles.css"> inside todo/index.html, where it resolves to
+ * todo/todo/styles.css and 404s. The page comes up as bare markup with no
+ * stylesheet and no script: no design, no behaviour, nothing in the console
+ * but two failed requests.
+ *
+ * It is the tool's own convention leaking into the file, so the tool takes it
+ * back out. Only a leading "<folder>/" on a relative reference, which inside
+ * that folder is always wrong — absolute paths, URLs, data: and anchors are
+ * left exactly as they are.
+ */
+async function unprefixOwnFolder(appDir, written) {
+  const prefix = `${path.basename(appDir)}/`;
+  const fixed = [];
+
+  for (const abs of written) {
+    if (!/\.html?$/i.test(abs)) continue;
+    const text = await fs.readFile(abs, 'utf8').catch(() => null);
+    if (text === null) continue;
+
+    let hits = 0;
+    const next = text.replace(ASSET_REF, (all, attr, quote, value) => {
+      if (!value.startsWith(prefix)) return all;
+      hits++;
+      return `${attr}=${quote}${value.slice(prefix.length)}${quote}`;
+    });
+
+    if (hits) {
+      await fs.writeFile(abs, next, 'utf8');
+      fixed.push(`${path.relative(appDir, abs).split(path.sep).join('/')} (${hits})`);
+    }
+  }
+  return fixed;
+}
+
+async function keepDesignTokens(appDir, template, written, starterCss) {
+  const rel = TOKEN_FILE[template];
+  if (!rel || !starterCss) return null;
+
+  const abs = path.join(appDir, rel);
+  if (!written.has(abs)) return null;                 // never overwritten
+
+  const now = await fs.readFile(abs, 'utf8').catch(() => null);
+  if (now === null || /:root\s*\{[^}]*--/.test(now)) return null;
+
+  const block = /:root\s*\{[\s\S]*?\n\}/.exec(starterCss);
+  if (!block) return null;
+
+  await fs.writeFile(abs, `${block[0]}\n\n${now}`, 'utf8');
+  return rel;
+}
+
 export async function applyDesign(appDir, design) {
   const dir = path.join(appDir, 'presets');
   const names = (await fs.readdir(dir).catch(() => [])).filter((f) => f.endsWith('.json'));
@@ -304,12 +304,21 @@ export async function createApp({ folder, name, description, template = 'plain-h
   } catch {
     existing = [];
   }
-  if (existing.length) {
+  // A folder with something already in it, and the whole app passed in
+  // alongside: that is the second attempt at a build that half happened.
+  // Refusing it is how a Next.js build spent two calls being told no and then
+  // started over from nothing. The starter is already on disk — take the files
+  // and write them into it.
+  //
+  // With no files it is still a refusal, because then there is nothing to do
+  // but copy a starter over work that is already there.
+  const adopt = existing.length > 0 && given.length > 0;
+  if (existing.length && !adopt) {
     throw new ToolFailure({
       kind: 'not_empty',
       attempted,
       failed: `${target.show} already has ${existing.length} item(s) in it: ${existing.slice(0, 5).join(', ')}.`,
-      fix: 'Pick a new folder name. If this folder is the app from an earlier attempt, work in it instead of creating it again.',
+      fix: 'Pick a new folder name, or pass the app in "files" to write it into the folder that is already there.',
     });
   }
 
@@ -320,23 +329,23 @@ export async function createApp({ folder, name, description, template = 'plain-h
     __APP_DESCRIPTION__: plain(description) || display,
   };
 
-  const copied = await copyTree(path.join(TEMPLATES, template), target.abs, fill);
+  const copied = adopt ? [] : await copyTree(path.join(TEMPLATES, template), target.abs, fill);
   // Next.js serves static files from public/; a plain page has no such place
   // and an empty folder in a three-file app is clutter.
-  if (template !== 'plain-html') await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
-  const look = await applyDesign(target.abs, design);
-
-  // Read before the app's own files land on top of it, so the tokens can be
-  // put back if the replacement arrives without any.
-  const starterCss = TOKEN_FILE[template]
-    ? await fs.readFile(path.join(target.abs, TOKEN_FILE[template]), 'utf8').catch(() => null)
+  if (!adopt && template !== 'plain-html') await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
+  const look = await applyDesign(target.abs, design);
+
+  // Read before the app's own files land on top of it, so the tokens can be
+  // put back if the replacement arrives without any.
+  const starterCss = TOKEN_FILE[template]
+    ? await fs.readFile(path.join(target.abs, TOKEN_FILE[template]), 'utf8').catch(() => null)
     : null;
 
   // The starter has been installed on this machine before: hard-link that
   // tree in, which is seconds where npm is a minute. Otherwise install as
   // usual, and keep the result so the next app is instant.
   let linked = 0;
-  const needsInstall = template !== 'plain-html';
+  const needsInstall = !adopt && template !== 'plain-html';
   if (install && needsInstall) {
     // Keyed on the starter's lockfile, which is the same for every app made
     // from it — the app's own is rewritten by npm as it installs.
@@ -359,8 +368,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // one, and round trips are nearly all of the time a build takes.
   const mine = given;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
-  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
-  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
+  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
+  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
   const relinked = await unprefixOwnFolder(target.abs, written);
 
   // The starter's own files, in full, so there is never a reason to read them
@@ -377,20 +386,20 @@ export async function createApp({ folder, name, description, template = 'plain-h
   const out = result(
     `Created ${target.show} from the ${template} starter — ${copied.length} files, already known to build.\n` +
       (look ? `Design: the ${look.name} preset (${look.summary}), font ${look.fonts?.sans ?? 'Geist'}.\n` : '') +
-      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
-      (relinked.length
-        ? `\nFixed in ${relinked.join(', ')}: links that began with "${path.basename(target.abs)}/". ` +
-          'Paths in "files" are relative to the project root, but a link inside a page is ' +
-          'relative to that page — so "index.html" beside "styles.css" links to it as ' +
-          '"styles.css", never "app/styles.css". Written that way the stylesheet and the ' +
-          'script 404 and the page comes up as bare markup.\n'
-        : '') +
-      (keptTokens
-        ? `\nYour ${keptTokens} arrived with no :root block, so the starter's was kept above it — ` +
-          'the palette, the spacing scale (--s1 to --s5), the radius and the motion timings. ' +
-          'Build the rest of the stylesheet out of those variables: spacing that comes from a ' +
-          'scale is the difference between a designed page and an arranged one. Re-tint the ' +
-          'values to suit this app; do not go back to raw pixels.\n'
+      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
+      (relinked.length
+        ? `\nFixed in ${relinked.join(', ')}: links that began with "${path.basename(target.abs)}/". ` +
+          'Paths in "files" are relative to the project root, but a link inside a page is ' +
+          'relative to that page — so "index.html" beside "styles.css" links to it as ' +
+          '"styles.css", never "app/styles.css". Written that way the stylesheet and the ' +
+          'script 404 and the page comes up as bare markup.\n'
+        : '') +
+      (keptTokens
+        ? `\nYour ${keptTokens} arrived with no :root block, so the starter's was kept above it — ` +
+          'the palette, the spacing scale (--s1 to --s5), the radius and the motion timings. ' +
+          'Build the rest of the stylesheet out of those variables: spacing that comes from a ' +
+          'scale is the difference between a designed page and an arranged one. Re-tint the ' +
+          'values to suit this app; do not go back to raw pixels.\n'
         : '') +
       (linked
         ? `Its packages are already in place (${linked.toLocaleString()} files, linked from the starter cache) — ` +

package/src/ui/screen.js

@@ -60,7 +60,7 @@ export function isLabel(text) {
 export const COMMANDS = [
   '/help', '/model', '/models', '/session', '/sessions', '/resume',
   '/new', '/remember', '/skills', '/clear', '/search', '/copy', '/exit',
-  '/stats', '/doctor', '/deploy', '/look',
+  '/stats', '/doctor', '/deploy', '/look', '/undo',
 ];
 
 // ANSI ----------------------------------------------------------------------
@@ -473,6 +473,19 @@ export class Screen {
    * there buries the answer under a copy of something already on disk, so
    * what is kept is the shape of the change: how much arrived, how much left.
    */
+  /**
+   * A one-word verdict on the step that just ran — "clean", "3 to fix".
+   *
+   * Same rule as diffStat: it goes on the line that named the step. Nothing
+   * goes underneath a bullet, and a result line per tool doubles the height of
+   * the transcript to say "ok".
+   */
+  runStat(text) {
+    if (!this.run || !text) return;
+    this.run.stat = text;
+    this.paintRun();
+  }
+
   diffStat({ added = 0, removed = 0 } = {}) {
     if (!this.run) return;
     this.run.added += added;

package/src/ui/theme.js

@@ -481,10 +481,16 @@ export const groupTarget = (label) => String(label ?? '').trim().split(/\s+/).sl
  * asLabel() already: run that over this and its regexes would be reading
  * escape sequences instead of the last word.
  */
-export function runLine({ label, count = 1, targets = [], added = 0, removed = 0 }) {
+export function runLine({ label, count = 1, targets = [], added = 0, removed = 0, stat = '' }) {
+  // What came of the step, in the same place a change puts its two numbers:
+  // on the line that named the step, never underneath it. A look that found
+  // three things to fix is the one fact worth carrying out of a look, and
+  // without it the most thorough check ucode runs is the quietest thing on
+  // screen — it opens the app at two widths, screenshots both and has them
+  // reviewed, and said nothing about any of it.
   const counts = added || removed
     ? ` ${chalk.hex('#3fb950')(`+${added}`)} ${chalk.hex('#f2939c')(`-${removed}`)}`
-    : '';
+    : (stat ? `  ${sky(stat)}` : '');
   if (count <= 1) return `${paintStep(label)}${counts}`;
 
   const g = GROUPS[groupKind(label)];