ucode-agent 1.3.0 → 1.4.0

package/README.md

@@ -19,7 +19,7 @@ corner:
   ╭──────────────────────────────────────────────────────────────────────────────╮
   │ › Ask anything…                                                              │
   │                                                                              │
-  │ ◆ Build · Nemotron 3 Ultra                                                0% │
+  │ ◆ Build · North Mini Code                                                 0% │
   ╰──────────────────────────────────────────────────────────────────────────────╯
 
 
@@ -44,7 +44,7 @@ the input, so your own words are easy to find in a long session:
 ╭──────────────────────────────────────────────────────────────────────────────────╮
 │ › now add a dark mode toggle                                                     │
 │                                                                                  │
-│ ◆ Build · Nemotron 3 Ultra                                                    4% │
+│ ◆ Build · North Mini Code                                                     4% │
 ╰──────────────────────────────────────────────────────────────────────────────────╯
 ```
 
@@ -88,24 +88,32 @@ properly, which is the thing an agent actually depends on.
 
 | Model | Context | For |
 | --- | --- | --- |
-| **Nemotron 3 Ultra** ★ | 1M | the default — deepest reasoning, slowest to first token |
+| Nemotron 3 Ultra | 1M | deepest reasoning, slowest to first token |
 | Nemotron 3.5 Lightning | 1M | the same enormous window, answers much sooner |
 | Nemotron 3 Super | 262k | strong all-rounder, quick to start |
 | Nemotron 3 Nano Omni | 256k | small, fast, reasoning tuned |
-| **North Mini Code** ★ | 256k | code and UI specialist — reach for it on frontend work |
+| **North Mini Code** ★ | 256k | the default — built for code and interface work, quick to answer |
 
 `/model` shows them and switches. `ucode -m cohere/north-mini-code:free`
 starts on one.
 
-Ultra is the default because the work this is for — read a codebase, hold it in
-mind, change several files consistently — is what a million-token window and a
-long think are for. When the wait stops being worth it, switch.
+North Mini Code is the default: it is built for code and interfaces, which is most
+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.
 
 ## What it does
 
-**Thirteen tools.** `read_file`, `read_files`, `write_file`, `batch_write`,
+**Fourteen tools.** `read_file`, `read_files`, `write_file`, `batch_write`,
 `edit_file`, `multi_edit`, `edit_files`, `list_dir`, `glob`, `grep`,
-`run_command`, `run_commands`, `web_search`. Read-only calls run in parallel,
+`run_command`, `run_commands`, `look_at_app`, `web_search`. Read-only calls run in parallel,
 and start the moment the model finishes writing them — while the rest of its
 reply is still arriving. Anything that writes runs on its own, in order.
 
@@ -119,6 +127,14 @@ 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.
+
 **Errors fixed before you see them.** When the model says it is done, ucode
 type-checks every file it changed — `tsc --noEmit` for TypeScript projects,
 a syntax check for JavaScript and Python — and hands any errors back to fix,
@@ -154,7 +170,12 @@ them; the chip inside the input box says which is live.
 
 **Sessions.** Everything is on disk under `~/.ucode/sessions`, saved after every
 step. `/resume` lists them with what each one was actually about, the ones from
-this folder first.
+this folder first. Press `d` twice on one to delete it — the list stays open, so
+clearing out several is quick — or `/session delete 2,5`.
+
+**It updates itself.** Each launch checks npm in the background and, if there is
+a newer version, installs it while you work. The next launch is the new one.
+Set `UCODE_NO_UPDATE=1` to turn that off.
 
 **A context window that folds rather than forgets.** Past 75% the oldest turns
 are summarised instead of dropped, never cutting between a tool call and its
@@ -207,6 +228,7 @@ Everything after the frontmatter is the instruction.
 | `/help` | the list |
 | `/model` | show the models and switch — `/models` does the same |
 | `/resume` | pick up an earlier conversation — `/session`, `/sessions` too |
+| `/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` |
 | `/skills` | what it knows how to do, and what is loaded |
@@ -245,7 +267,7 @@ ucode [options]
 Environment overrides: `UCODE_MODEL`, `UCODE_WORKER_MODEL` (a faster model for
 parallel workers), `UCODE_WORKER_STEPS`, `UCODE_MAX_CONTEXT_TOKENS`,
 `UCODE_MAX_STEPS`, `UCODE_MAX_TOOL_OUTPUT`, `UCODE_REQUEST_TIMEOUT_MS`,
-`UCODE_BASE_URL`.
+`UCODE_BASE_URL`, `UCODE_NO_UPDATE`.
 
 Web search needs a Tavily key — free, 1000 searches a month, no card. Without
 one, ucode answers from what it knows and says that it could not check.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -48,6 +48,7 @@
     "dotenv": "^17.4.2",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "openai": "^7.4.0"
+    "openai": "^7.4.0",
+    "playwright-core": "^1.63.0"
   }
 }

package/skills/build-app/SKILL.md

@@ -141,8 +141,10 @@ Use `batch_write` for the skeleton — one call, every file.
 - `npm run build` — it type-checks and lints; a build that fails is not done.
 - Start it: `npm run dev` goes to the background on its own and comes back with
   the URL once ready. Do not start it twice.
-- Exercise it: `curl` the API route with real input, load the page, check the
-  core loop end to end. A clean build proves it compiles, not that it works.
+- Exercise it: `curl` the API route with real input, then `look_at_app` on every
+  page — it loads them in a real browser at phone and desktop width and reports
+  errors, overflow and a visual review. A clean build proves it compiles, not
+  that it works.
 - Fix what you find and check again.
 
 ## 7. Definition of done

package/skills/ui-ux/SKILL.md

@@ -283,7 +283,11 @@ because it was first to hand means you were not deciding.
 
 ## 9. Look at it, then report
 
-Run it (`npm run dev` starts in the background and returns the URL) and check:
+Run it (`npm run dev` starts in the background and returns the URL), then call
+`look_at_app` with that URL. It opens the app in a real browser at 375px and
+1440px, reports console errors, failed requests, overflow, broken images and
+unlabeled controls, and returns a designer's review of the screenshots. Fix what
+it finds and look again. Then check:
 
 1. **375px wide** — no horizontal scroll, nothing overlapping or clipped. If you
    wrote no responsive rules at all, you have not done this.

package/src/core/loop.js

@@ -17,14 +17,16 @@ import { spawn } from 'node:child_process';
 
 import {
   ask, model, setModel, modelName, modelList, contextLimit, rateLimits,
-  MODELS, DEFAULT_MODEL, PROVIDER,
+  MODELS, DEFAULT_MODEL, PROVIDER, fallbackFor,
 } from './provider.js';
 import {
   tools, runTool, describe, setRoot, setConfirm, PARALLEL_SAFE, WRITES, FILE_WRITES,
 } from '../tools/index.js';
 import { projectMap, loadMemory, remember, MEMORY_FILE } from './context.js';
+import { autoUpdate } from './updater.js';
+import { closeBrowser } from '../tools/browser.js';
 import {
-  newSession, save, load, list, removeAll, titleFrom,
+  newSession, save, load, list, remove, removeAll, titleFrom,
 } from './history.js';
 import { fold, usage, tooBig, SUMMARY_PROMPT, forSummary } from './window.js';
 import { loadSkills, catalogue, findSkill, skillMessage, autoLoadFor } from './skills.js';
@@ -64,6 +66,17 @@ const MAX_FIX_ROUNDS = 3;
 /** Files worth checking after they change. */
 const CHECKABLE = /\.(?:[cm]?[jt]sx?|py)$/i;
 
+/**
+ * Failures that are the provider's and not the model's: busy, slow, down, or
+ * unreachable. None of them should end a build — the turn moves to another
+ * model and carries on from exactly where it was.
+ */
+const TRANSIENT = new Set(['rate_limit', 'timeout', 'server', 'network', 'no_content']);
+const MAX_FAILOVERS = 8;
+const COOLDOWN = 5 * 60_000;
+
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+
 /** Parallel workers at once, and how many steps each may take. */
 const MAX_WORKERS = 3;
 const WORKER_STEPS = Number(process.env.UCODE_WORKER_STEPS) || 60;
@@ -129,7 +142,7 @@ const delegateTool = {
 };
 
 /** The instructions a parallel worker starts with. */
-function workerPrompt({ cwd, name, memory, skills }) {
+function workerPrompt({ cwd, name, memory, skills, map }) {
   return [
     `You are a ucode worker called "${name}" - one of several building parts of the same project at the same time.`,
     '',
@@ -145,7 +158,11 @@ function workerPrompt({ cwd, name, memory, skills }) {
     '- Finish what you build: real content, every state handled, no TODOs.',
     '- When done, reply with two or three sentences: what you built, in which files, and',
     '  anything the lead has to wire up.',
+    '- The files you own may not exist yet - create them. Do not go looking for them',
+    '  first. The project map below shows what does exist; read only the files whose',
+    '  interfaces you must match, then start writing within two or three steps.',
     ...(memory ? ['', '## Project memory', '', memory] : []),
+    ...(map ? ['', '## Project map', '', map] : []),
     ...(skills ? ['', '## Instructions in force', '', skills] : []),
   ].join('\n');
 }
@@ -234,6 +251,9 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '  writing files. Running the install yourself afterwards just waits for that one.',
     '- When you finish, ucode type-checks what you changed and hands you the errors, so',
     '  there is no need to run tsc yourself.',
+    '- Once the dev server is ready, run look_at_app on the pages you built and fix what',
+    '  it reports - errors, layout that overflows a phone, and the visual review - then',
+    '  look again. Do not call an interface finished before it has been looked at.',
     '- Nothing you run has a keyboard. Pass the non-interactive flag to anything that',
     '  would ask a question, or it fails instead of waiting: create-next-app --yes,',
     '  npx shadcn@latest init -d -y, npx shadcn@latest add <names> -y, npm init -y.',
@@ -373,6 +393,14 @@ export class Agent {
 
     this.showHeader();
     this.installSignals();
+
+    // Checked in the background; nothing here waits on it.
+    autoUpdate({
+      onUpdated: (version) => {
+        this.ui.setFacts?.({ update: version });
+        if (!this.ui.welcoming?.()) this.ui.note(`updated to v${version} — it takes over the next time you start ucode`);
+      },
+    });
     await this.repl();
   }
 
@@ -485,6 +513,7 @@ export class Agent {
   }
 
   async shutdown() {
+    await closeBrowser().catch(() => {});
     this.ui.stopSpinner();
     if (this.session.messages.length) {
       await this.persist();
@@ -559,6 +588,14 @@ export class Agent {
     ]);
     await this.persist();
 
+    // A busy model was swapped for a fallback earlier; after a few minutes the
+    // one the user chose gets another go.
+    this.preferred ??= model();
+    if (model() !== this.preferred && Date.now() > (this.cooldownUntil ?? 0)) {
+      setModel(this.preferred);
+      if (this.full) this.showHeader({ clear: false });
+    }
+
     this.busy = true;
     this.abort = new AbortController();
 
@@ -591,6 +628,8 @@ export class Agent {
     let askedToVerify = false;
     let askedToSpeak = false;
     let fixRounds = 0;
+    this.failovers = 0;
+    this.tried = new Set([model()]);
 
     this.touched = new Set();
     this.sinceCheck = new Set();
@@ -668,6 +707,10 @@ export class Agent {
           });
           continue;
         }
+
+        // Busy, slow or down: move to the next model and carry on, rather
+        // than ending a half-built app with an error.
+        if (TRANSIENT.has(err.kind) && !this.abort.signal.aborted && (await this.failover(err))) continue;
         throw err;
       }
 
@@ -917,6 +960,38 @@ export class Agent {
     });
   }
 
+  /**
+   * Switch to the next model after a provider failure. Returns false once
+   * there is nothing sensible left to try. When every model is busy at once,
+   * it waits a minute and goes round again rather than giving up.
+   */
+  async failover(err) {
+    if (++this.failovers > MAX_FAILOVERS) return false;
+    const from = model();
+    let next = fallbackFor(from, this.tried);
+
+    if (!next) {
+      const until = Date.now() + 60_000;
+      this.ui.startSpinner('every model is busy');
+      while (Date.now() < until && !this.abort?.signal.aborted) {
+        this.ui.updateSpinner(`every model is busy — trying again in ${Math.ceil((until - Date.now()) / 1000)}s`);
+        await wait(1000);
+      }
+      this.ui.stopSpinner();
+      if (this.abort?.signal.aborted) return false;
+      this.tried = new Set();
+      next = this.preferred && this.preferred !== from ? this.preferred : fallbackFor(from, this.tried) ?? from;
+    }
+
+    this.tried.add(next);
+    setModel(next);
+    this.cooldownUntil = Date.now() + COOLDOWN;
+    const why = err.kind === 'rate_limit' ? 'busy' : err.kind === 'timeout' ? 'too slow to answer' : 'not answering';
+    this.ui.note(`${modelName(from)} is ${why} — carrying on with ${modelName(next)}`);
+    if (this.full) this.showHeader({ clear: false });
+    return true;
+  }
+
   /** Run a call and settle to { out } or { err } — never throws. */
   execute(call) {
     return this.dispatch(call).then((out) => ({ out }), (err) => ({ err }));
@@ -964,10 +1039,18 @@ export class Agent {
 
     for (const r of results) for (const f of r.touched) { this.touched.add(f); this.sinceCheck.add(f); }
 
+    // A worker that wrote nothing has not done its part, whatever it said.
+    // The lead builds those itself rather than leaving holes in the app.
+    const empty = results.filter((r) => !r.touched.length).map((r) => r.name);
+
     return {
       content: results
         .map((r) => `## ${r.name}\n${r.summary}\nFiles changed: ${r.touched.join(', ') || 'none'}`)
-        .join('\n\n'),
+        .join('\n\n') +
+        (empty.length
+          ? `\n\n${empty.join(', ')} wrote no files. Build ${empty.length === 1 ? 'that part' : 'those parts'} ` +
+            'yourself now, directly - do not delegate them again.'
+          : ''),
       summary: results.map((r) => `${r.name} · ${r.touched.length} file${r.touched.length === 1 ? '' : 's'}`).join('  '),
     };
   }
@@ -980,16 +1063,39 @@ export class Agent {
       .map((s) => `--- ${s.name} ---\n${s.body}`)
       .join('\n\n');
     const messages = [
-      { role: 'system', content: workerPrompt({ cwd: this.cwd, name, memory: this.memory, skills }) },
+      { role: 'system', content: workerPrompt({ cwd: this.cwd, name, memory: this.memory, skills, map: this.map }) },
       { role: 'user', content: String(task.instructions) },
     ];
     const available = this.toolsNow().filter((t) => !WORKER_EXCLUDED.has(t.name));
     const wanted = process.env.UCODE_WORKER_MODEL;
-    const workerModel = wanted && MODELS[wanted] ? wanted : model();
+    let workerModel = wanted && MODELS[wanted] ? wanted : model();
+    const tried = new Set([workerModel]);
+    let failovers = 0;
+
+    // Start a moment apart. Three requests in the same instant is exactly what
+    // trips a free endpoint's rate limit, and the stagger costs a second or two.
+    if (index) await wait(index * 1500);
 
     for (let step = 0; step < WORKER_STEPS; step++) {
       if (this.abort?.signal.aborted) break;
-      const reply = await ask(messages, available, { signal: this.abort?.signal, model: workerModel });
+
+      let reply;
+      try {
+        reply = await ask(messages, available, { signal: this.abort?.signal, model: workerModel });
+      } catch (err) {
+        // Same rule as the lead: a busy model is swapped, not a reason to stop.
+        if (TRANSIENT.has(err.kind) && failovers < 6 && !this.abort?.signal.aborted) {
+          failovers++;
+          let next = fallbackFor(workerModel, tried);
+          if (!next) { tried.clear(); await wait(20_000); next = fallbackFor(workerModel, tried) ?? workerModel; }
+          tried.add(next);
+          this.ui.note(`${name}: ${modelName(workerModel)} is busy — switching to ${modelName(next)}`);
+          workerModel = next;
+          step--;
+          continue;
+        }
+        throw err;
+      }
       this.record(reply.usage);
 
       if (!reply.toolCalls.length) {
@@ -1220,6 +1326,7 @@ export class Agent {
     if (arg) {
       try {
         setModel(arg);
+        this.preferred = model();
       } catch (err) {
         this.ui.error(err, { debug: this.debug });
         return;
@@ -1247,6 +1354,7 @@ export class Agent {
       if (chosen === null) return;
 
       setModel(all[chosen].id);
+      this.preferred = model();
       this.session.model = model();
       this.ui.note(`now using ${modelName()}`);
       this.showHeader({ clear: false });
@@ -1285,7 +1393,7 @@ export class Agent {
    * and how far it got, and the ones from this folder are marked, because that
    * is nearly always the one being looked for.
    */
-  describeSession(s, width) {
+  describeSession(s, width, i) {
     const room = Math.max(24, Math.min(46, width - 34));
     const mark = s.mine ? blue('●') : dim('○');
     const when = relativeTime(s.updatedAt).padEnd(9);
@@ -1293,7 +1401,8 @@ export class Agent {
     const where = s.mine ? 'here' : shortenPath(s.cwd, 26);
 
     return {
-      label: `${mark} ${clip(s.title, room).padEnd(room)}  ${dim(when)}${dim(turns)}${dim(where)}`,
+      // Numbered in the picker, so /session delete 3 has something to point at.
+      label: `${i === undefined ? '' : `${dim(String(i + 1).padStart(2))} `}${mark} ${clip(s.title, room).padEnd(room)}  ${dim(when)}${dim(turns)}${dim(where)}`,
       sub: s.preview ? dim(`     ${clip(s.preview, width - 10)}`) : '',
     };
   }
@@ -1314,6 +1423,10 @@ export class Agent {
       return;
     }
 
+    // /session delete 3   or   /session delete 2,5,7
+    const del = /^(?:delete|del|rm|remove)\b\s*(.*)$/i.exec(arg ?? '');
+    if (del) return this.deleteSessions(del[1]);
+
     const sessions = await list({ cwd: this.cwd });
     if (!sessions.length) {
       this.ui.note('no saved conversations yet');
@@ -1336,22 +1449,48 @@ export class Agent {
       }
       index = n - 1;
     } else if (this.ui.pick) {
-      const here = shown.filter((s) => s.mine).length;
-      index = await this.ui.pick(
-        shown.map((s) => this.describeSession(s, width)),
-        {
-          hint:
-            `↑↓ move · enter to continue · esc to cancel` +
-            (here ? ` — ${here} from this folder` : '') +
-            (sessions.length > shown.length ? ` · ${sessions.length - shown.length} older not shown` : ''),
+      // The picker stays open while you delete, so clearing out several old
+      // conversations is d d, d d, d d — then Enter on the one you want.
+      let active = 0;
+      for (;;) {
+        const here = shown.filter((s) => s.mine).length;
+        const picked = await this.ui.pick(
+          shown.map((s, i) => this.describeSession(s, width, i)),
+          {
+            active,
+            deletable: true,
+            hint:
+              `↑↓ move · enter to continue · d twice to delete · esc to cancel` +
+              (here ? ` — ${here} from this folder` : ''),
+          }
+        );
+        if (picked === null) return;
+        if (typeof picked === 'object' && picked.delete !== undefined) {
+          const doomed = shown[picked.delete];
+          active = picked.delete;
+          if (doomed.id === this.session.id) {
+            this.ui.flash?.('that is the conversation you are in — /new first, then delete it');
+            continue;
+          }
+          await remove(doomed.id);
+          shown.splice(picked.delete, 1);
+          this.ui.flash?.(`deleted · ${clip(doomed.title, 50)}`);
+          if (!shown.length) {
+            this.ui.note('no saved conversations left');
+            return;
+          }
+          active = Math.min(active, shown.length - 1);
+          continue;
         }
-      );
-      if (index === null) return;
+        index = picked;
+        break;
+      }
     } else {
       this.ui.blank();
+      this.ui.note('/session delete <number> removes one, or several: /session delete 2,5');
       index = await this.ui.choose(
         'continue which?',
-        shown.map((s) => this.describeSession(s, width).label)
+        shown.map((s, i) => this.describeSession(s, width, i).label)
       );
       if (index === null) return;
     }
@@ -1363,6 +1502,26 @@ export class Agent {
     }
   }
 
+  /** /session delete 3, or 2,5,7 — numbers as the session list shows them. */
+  async deleteSessions(spec) {
+    const sessions = (await list({ cwd: this.cwd })).slice(0, 25);
+    const numbers = [...new Set(String(spec).split(/[\s,]+/).filter(Boolean).map(Number))];
+    const bad = numbers.filter((n) => !Number.isInteger(n) || n < 1 || n > sessions.length);
+    if (!numbers.length || bad.length) {
+      this.ui.write(theme.warn(`  usage: /session delete <number>[,<number>…] — numbers from 1 to ${sessions.length}`));
+      return;
+    }
+    for (const n of numbers) {
+      const s = sessions[n - 1];
+      if (s.id === this.session.id) {
+        this.ui.note(`skipped ${n} — that is the conversation you are in`);
+        continue;
+      }
+      await remove(s.id);
+      this.ui.note(`deleted ${n} · ${s.title}`);
+    }
+  }
+
   async resume(id) {
     try {
       const loaded = await load(id);

package/src/core/provider.js

@@ -58,7 +58,7 @@ export const MODELS = {
     name: 'Nemotron 3 Ultra',
     context: 1_000_000,
     star: true,
-    note: 'deepest reasoning, 1M context — the default',
+    note: 'deepest reasoning, 1M context — slowest to answer',
   },
   'nvidia/nemotron-3.5-lightning:free': {
     name: 'Nemotron 3.5 Lightning',
@@ -79,18 +79,43 @@ export const MODELS = {
     name: 'North Mini Code',
     context: 256_000,
     star: true,
-    note: 'code and UI specialist — reach for it on frontend work',
+    note: 'the default — built for code and interface work, quick to answer',
   },
 };
 
 /**
- * Nemotron 3 Ultra is the default because the work ucode is for — read a
- * codebase, hold it in mind, change several files consistently — is exactly
- * what a million-token window and a long think buy you. It is slower to the
- * first token than the others and that is the trade being made. /model swaps
- * to Lightning or North Mini Code when the wait stops being worth it.
+ * North Mini Code is the default: it is built for code and interface work,
+ * which is what ucode is mostly asked to do, and it answers far sooner than
+ * the big reasoning models. /model moves to Ultra when a problem needs the
+ * million-token window and the long think more than it needs the speed.
  */
-export const DEFAULT_MODEL = 'nvidia/nemotron-3-ultra-550b-a55b:free';
+export const DEFAULT_MODEL = 'cohere/north-mini-code:free';
+
+/**
+ * Where to go when a model is busy, in order of preference. Each is served by
+ * a different upstream, so a rate limit on one rarely means a limit on the
+ * next — which is what lets a long build keep going instead of stopping at
+ * the first "too many requests".
+ */
+export const FALLBACKS = [
+  'cohere/north-mini-code:free',
+  'nvidia/nemotron-3.5-lightning:free',
+  'nvidia/nemotron-3-super-120b-a12b:free',
+  'nvidia/nemotron-3-ultra-550b-a55b:free',
+];
+
+/** The next model to try after `id`, skipping any already tried this round. */
+export function fallbackFor(id, tried = new Set()) {
+  const start = Math.max(0, FALLBACKS.indexOf(id));
+  for (let i = 1; i <= FALLBACKS.length; i++) {
+    const next = FALLBACKS[(start + i) % FALLBACKS.length];
+    if (next !== id && !tried.has(next)) return next;
+  }
+  return null;
+}
+
+/** Seconds to wait on successive rate limits that come with no retry-after. */
+const RATE_LIMIT_BACKOFF = [5, 10, 20];
 
 let current = process.env.UCODE_MODEL || DEFAULT_MODEL;
 let client = null;
@@ -578,12 +603,15 @@ export async function ask(messages, tools = [], opts = {}) {
       problem = explain(err, id);
 
       // A per-minute limit is a wait, not a failure. Sit it out rather than
-      // making the user retype their message.
-      const wait = problem.detail?.retryAfter;
+      // making the user retype their message. Free endpoints often refuse
+      // without saying how long to wait, so when there is no retry-after the
+      // pauses grow on their own — 5s, 10s, 20s — and only then does the
+      // error go up to the loop, which moves to another model.
+      const told = problem.detail?.retryAfter;
+      const wait = Number.isFinite(told) && told > 0 && told <= 90 ? told : RATE_LIMIT_BACKOFF[attempt - 1];
       if (
         problem.kind === 'rate_limit' && !problem.detail?.daily &&
-        Number.isFinite(wait) && wait > 0 && wait <= 90 &&
-        attempt < attempts && !opts.signal?.aborted
+        wait && attempt < attempts && printed === 0 && !opts.signal?.aborted
       ) {
         const until = Date.now() + wait * 1000;
         while (Date.now() < until && !opts.signal?.aborted) {

package/src/core/updater.js

@@ -0,0 +1,95 @@
+/**
+ * updater.js — staying current without anyone running npm by hand.
+ *
+ * On every launch ucode asks the registry, in the background, whether a newer
+ * version exists. If one does, it installs it globally, detached, while you
+ * work. The version you are running carries on untouched; the next launch is
+ * the new one. Nothing about starting ucode waits on any of this.
+ *
+ * It stays out of the way in three cases: a development checkout (updating
+ * would overwrite the `npm link` that points at your working copy), when
+ * UCODE_NO_UPDATE is set, and when another ucode is already updating.
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION } from './version.js';
+
+const PACKAGE = 'ucode-agent';
+const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const HOME = path.join(os.homedir(), '.ucode');
+const LOCK = path.join(HOME, 'update.lock');
+const LOG = path.join(HOME, 'update.log');
+const LOCK_TTL = 10 * 60_000;
+
+/** "1.10.0" > "1.9.3" — numeric, part by part. */
+export function newer(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  }
+  return false;
+}
+
+function isDevCheckout() {
+  return existsSync(path.join(PACKAGE_ROOT, '.git'));
+}
+
+async function latestVersion() {
+  const res = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`, {
+    signal: AbortSignal.timeout(5_000),
+    headers: { accept: 'application/json' },
+  });
+  if (!res.ok) return null;
+  return (await res.json())?.version ?? null;
+}
+
+async function takeLock() {
+  try {
+    const stat = await fs.stat(LOCK);
+    if (Date.now() - stat.mtimeMs < LOCK_TTL) return false;   // someone else is on it
+  } catch { /* no lock — good */ }
+  await fs.mkdir(HOME, { recursive: true });
+  await fs.writeFile(LOCK, String(process.pid));
+  return true;
+}
+
+/**
+ * Check, and install if there is something newer.
+ *
+ * @param {object} o
+ * @param {(v: string) => void} [o.onUpdated]  called when the install finishes
+ */
+export async function autoUpdate({ onUpdated } = {}) {
+  try {
+    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return;
+    const latest = await latestVersion();
+    if (!latest || !newer(latest, VERSION)) return;
+    if (!(await takeLock())) return;
+
+    const log = await fs.open(LOG, 'w');
+    const child = spawn(`npm install -g ${PACKAGE}@${latest} --no-audit --no-fund`, {
+      shell: true,
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', log.fd, log.fd],
+    });
+    await log.close();
+    child.unref();
+
+    child.on('exit', async (code) => {
+      await fs.rm(LOCK, { force: true }).catch(() => {});
+      if (code === 0) onUpdated?.(latest);
+    });
+    child.on('error', async () => {
+      await fs.rm(LOCK, { force: true }).catch(() => {});
+    });
+  } catch {
+    // An update check must never be the reason ucode misbehaves. Offline,
+    // registry down, no permission to install globally: all silently skipped.
+  }
+}

package/src/tools/browser.js

@@ -0,0 +1,258 @@
+/**
+ * browser.js — looking at the app the way a person would.
+ *
+ * A build that passes and a page that works are different claims. This opens
+ * the running app in a real browser at a phone width and a desktop width, and
+ * reports what a person would run into: errors in the console, requests that
+ * failed, a layout that spills off the side of a phone, broken images,
+ * controls with no name. It saves a screenshot of each, and has the one model
+ * in the set that can see — Nemotron Nano Omni — review them as a designer
+ * would. The model building the app then has something concrete to fix.
+ *
+ * It drives the browser already on the machine (Edge or Chrome) through
+ * playwright-core, so there is no separate 150 MB browser download.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { ToolFailure } from '../core/failure.js';
+import { ask } from '../core/provider.js';
+import { getRoot, result } from './shared.js';
+
+const VISION_MODEL = 'nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free';
+const WIDTHS = [
+  { name: 'phone', width: 375, height: 812 },
+  { name: 'desktop', width: 1440, height: 900 },
+];
+const LOCAL = /^https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?(?:\/|$)/i;
+
+let browserPromise = null;
+
+/**
+ * One browser for the whole session, started on first use. The installed
+ * Edge or Chrome is tried first; Playwright's own Chromium only if it happens
+ * to be installed.
+ */
+async function browser() {
+  if (browserPromise) return browserPromise;
+  browserPromise = (async () => {
+    let chromium;
+    try {
+      ({ chromium } = await import('playwright-core'));
+    } catch (err) {
+      throw new ToolFailure({
+        kind: 'no_playwright',
+        attempted: 'starting a browser',
+        failed: `playwright-core could not be loaded: ${err.message}`,
+        fix: 'Reinstall ucode (npm install -g ucode-agent). Carry on without looking at the app, and say so.',
+      });
+    }
+    const tried = [];
+    for (const channel of ['msedge', 'chrome', undefined]) {
+      try {
+        return await chromium.launch({ channel, headless: true });
+      } catch (err) {
+        tried.push(`${channel ?? 'bundled chromium'}: ${String(err.message).split('\n')[0]}`);
+      }
+    }
+    throw new ToolFailure({
+      kind: 'no_browser',
+      attempted: 'starting a browser',
+      failed: `No browser could be started. Tried ${tried.join('; ')}.`,
+      fix: 'Install Google Chrome or Microsoft Edge. Carry on without looking at the app, and say so.',
+    });
+  })();
+  browserPromise.catch(() => { browserPromise = null; });
+  return browserPromise;
+}
+
+/** Close the shared browser, if one was started. Called when ucode exits. */
+export async function closeBrowser() {
+  if (!browserPromise) return;
+  try { await (await browserPromise).close(); } catch { /* already gone */ }
+  browserPromise = null;
+}
+
+/** Layout and accessibility checks run inside the page. */
+function inspect() {
+  const vw = window.innerWidth;
+  const describeEl = (el) => {
+    const id = el.id ? `#${el.id}` : '';
+    const cls = typeof el.className === 'string' && el.className.trim()
+      ? `.${el.className.trim().split(/\s+/).slice(0, 2).join('.')}` : '';
+    const text = (el.innerText || el.getAttribute('aria-label') || '').trim().replace(/\s+/g, ' ').slice(0, 40);
+    return `<${el.tagName.toLowerCase()}${id}${cls}>${text ? ` "${text}"` : ''}`;
+  };
+
+  const overflow = document.documentElement.scrollWidth - vw;
+  const wide = [];
+  if (overflow > 1) {
+    for (const el of document.querySelectorAll('body *')) {
+      const r = el.getBoundingClientRect();
+      if (r.width > 0 && r.right > vw + 1 && getComputedStyle(el).position !== 'fixed') {
+        wide.push(`${describeEl(el)} reaches ${Math.round(r.right)}px`);
+        if (wide.length >= 5) break;
+      }
+    }
+  }
+
+  const broken = [...document.images].filter((i) => i.complete && i.naturalWidth === 0).map((i) => i.src.slice(0, 80));
+  const noAlt = [...document.images].filter((i) => !i.hasAttribute('alt')).length;
+  const unnamed = [...document.querySelectorAll('button, a[href], [role="button"]')]
+    .filter((el) => !(el.innerText || '').trim() && !el.getAttribute('aria-label') && !el.getAttribute('title')
+      && !el.querySelector('[aria-label], title, img[alt]:not([alt=""])'))
+    .slice(0, 5).map(describeEl);
+  const inputsNoLabel = [...document.querySelectorAll('input:not([type="hidden"]), textarea, select')]
+    .filter((el) => !(el.id && document.querySelector(`label[for="${el.id}"]`)) && !el.closest('label')
+      && !el.getAttribute('aria-label') && !el.getAttribute('aria-labelledby'))
+    .length;
+  const tiny = vw < 600
+    ? [...document.querySelectorAll('button, a[href], [role="button"], input, select')]
+        .filter((el) => { const r = el.getBoundingClientRect(); return r.width > 0 && (r.height < 32 || r.width < 32); })
+        .length
+    : 0;
+  const smallText = [...document.querySelectorAll('p, li, span, a, button, label, td')]
+    .filter((el) => el.childElementCount === 0 && (el.innerText || '').trim() && parseFloat(getComputedStyle(el).fontSize) < 12)
+    .length;
+
+  return {
+    title: document.title,
+    overflow: overflow > 1 ? Math.round(overflow) : 0,
+    wide, broken, noAlt, unnamed, inputsNoLabel, tiny, smallText,
+    empty: !(document.body.innerText || '').trim(),
+  };
+}
+
+const safeName = (p) => (p === '/' ? 'home' : p.replace(/^\/+|\/+$/g, '').replace(/[^\w-]+/g, '_')) || 'page';
+
+async function review(shots) {
+  const request = [
+    {
+      role: 'system',
+      content:
+        'You are a senior product designer reviewing screenshots of a web app, one at a phone width ' +
+        'and one at desktop width. List the concrete visual problems a user would notice, most ' +
+        'important first: broken or cramped layout, overflow, misalignment, weak hierarchy (is the ' +
+        'most important thing the most prominent?), inconsistent spacing, low contrast, default-looking ' +
+        'components, awkward empty states, text that is too small. For each: where it is, what is wrong, ' +
+        'and the specific fix. At most 8 points, one or two lines each. If it genuinely looks polished, ' +
+        'say so in one line and name the one thing that would improve it most. No preamble.',
+    },
+    {
+      role: 'user',
+      content: shots.map((s) => `${s.label}`).join(' and ') + '.',
+      images: shots.map((s) => s.dataUrl),
+    },
+  ];
+  const reply = await ask(request, [], { model: VISION_MODEL, temperature: 0.2, maxOutputTokens: 900 });
+  return reply.text.trim();
+}
+
+export async function lookAtApp({ url, paths = ['/'], review: wantReview = true }) {
+  const base = String(url ?? '').trim().replace(/\/+$/, '');
+  if (!LOCAL.test(`${base}/`)) {
+    throw new ToolFailure({
+      kind: 'bad_args',
+      attempted: 'looking at the app',
+      failed: `"${url}" is not a local address. This only opens apps running on this machine.`,
+      fix: 'Pass the URL the dev server reported, e.g. http://localhost:3000',
+    });
+  }
+
+  const pages = (Array.isArray(paths) && paths.length ? paths : ['/'])
+    .map((p) => `/${String(p).trim().replace(/^\/+/, '')}`)
+    .slice(0, 4);
+
+  const shotsDir = path.join(getRoot(), '.ucode', 'screenshots');
+  await fs.mkdir(shotsDir, { recursive: true });
+
+  const b = await browser();
+  const sections = [];
+  const toReview = [];
+  let problems = 0;
+
+  for (const pagePath of pages) {
+    for (const size of WIDTHS) {
+      const context = await b.newContext({ viewport: { width: size.width, height: size.height }, deviceScaleFactor: 1 });
+      const page = await context.newPage();
+      const errors = [];
+      const failed = [];
+      page.on('console', (m) => {
+        if (m.type() === 'error' && !/devtools|download the react/i.test(m.text())) errors.push(m.text().slice(0, 200));
+      });
+      page.on('pageerror', (e) => errors.push(`uncaught: ${String(e.message).slice(0, 200)}`));
+      page.on('requestfailed', (r) => failed.push(`${r.method()} ${r.url().slice(0, 100)} — ${r.failure()?.errorText ?? 'failed'}`));
+      page.on('response', (r) => { if (r.status() >= 400) failed.push(`${r.status()} ${r.url().slice(0, 100)}`); });
+
+      const target = `${base}${pagePath}`;
+      let loadError = null;
+      try {
+        // A dev server compiles a page on its first request, which can take a
+        // while; networkidle then waits for the page's own data to arrive.
+        await page.goto(target, { waitUntil: 'networkidle', timeout: 60_000 });
+      } catch (err) {
+        try { await page.goto(target, { waitUntil: 'load', timeout: 30_000 }); }
+        catch (err2) { loadError = String(err2.message).split('\n')[0]; }
+      }
+      await page.waitForTimeout(600); // let entrance animations settle
+
+      const file = path.join(shotsDir, `${safeName(pagePath)}-${size.name}.jpg`);
+      let facts = null;
+      if (!loadError) {
+        facts = await page.evaluate(inspect).catch((err) => ({ error: err.message }));
+        const buffer = await page.screenshot({ type: 'jpeg', quality: 70, fullPage: false });
+        await fs.writeFile(file, buffer);
+        toReview.push({ label: `${pagePath} at ${size.width}px (${size.name})`, dataUrl: `data:image/jpeg;base64,${buffer.toString('base64')}` });
+      }
+      await context.close();
+
+      const lines = [`### ${pagePath} at ${size.width}px (${size.name})`];
+      if (loadError) {
+        lines.push(`Could not load: ${loadError}`);
+        problems++;
+      } else {
+        lines.push(`Screenshot: ${path.relative(getRoot(), file).split(path.sep).join('/')}`);
+        if (facts?.empty) { lines.push('- The page rendered no visible text at all.'); problems++; }
+        if (facts?.overflow) {
+          lines.push(`- Content is ${facts.overflow}px wider than the screen, so it scrolls sideways:`, ...facts.wide.map((w) => `  - ${w}`));
+          problems++;
+        }
+        if (facts?.broken?.length) { lines.push(`- Broken images: ${facts.broken.join(', ')}`); problems++; }
+        if (facts?.unnamed?.length) { lines.push(`- Buttons or links with no accessible name: ${facts.unnamed.join(', ')}`); problems++; }
+        if (facts?.inputsNoLabel) { lines.push(`- ${facts.inputsNoLabel} form field(s) without a label.`); problems++; }
+        if (facts?.noAlt) lines.push(`- ${facts.noAlt} image(s) without alt text.`);
+        if (facts?.tiny) lines.push(`- ${facts.tiny} tap target(s) smaller than 32px on a phone.`);
+        if (facts?.smallText) lines.push(`- ${facts.smallText} text element(s) under 12px.`);
+      }
+      if (errors.length) { lines.push('- Console errors:', ...[...new Set(errors)].slice(0, 6).map((e) => `  - ${e}`)); problems++; }
+      if (failed.length) { lines.push('- Failed requests:', ...[...new Set(failed)].slice(0, 6).map((f) => `  - ${f}`)); problems++; }
+      if (lines.length === 2 && !loadError) lines.push('- No errors, no overflow, nothing unlabeled.');
+      sections.push(lines.join('\n'));
+    }
+  }
+
+  let critique = '';
+  if (wantReview !== false && toReview.length) {
+    try {
+      critique = await review(toReview.slice(0, 4));
+    } catch (err) {
+      critique = `(The visual review could not run: ${err.failed ?? err.message}. The checks above still apply.)`;
+    }
+  }
+
+  const body = [
+    ...sections,
+    critique ? `## Visual review\n${critique}` : '',
+    '',
+    problems
+      ? 'Fix the problems above, then look again to confirm.'
+      : 'The automatic checks found nothing. Weigh the visual review, fix what is worth fixing.',
+  ].filter(Boolean).join('\n\n');
+
+  return result(
+    body,
+    problems
+      ? `${problems} problem${problems === 1 ? '' : 's'} found · screenshots in .ucode/screenshots`
+      : 'no errors · screenshots in .ucode/screenshots'
+  );
+}

package/src/tools/index.js

@@ -8,6 +8,7 @@ import { readFile, readFiles, writeFile, batchWrite, editFile, multiEdit, editFi
 import { listDir, glob, grep } from './search.js';
 import { runCommand, runCommands } from './shell.js';
 import { webSearch } from './web.js';
+import { lookAtApp } from './browser.js';
 import { clip, READ_LINES } from './shared.js';
 
 export { setRoot, setConfirm, getRoot } from './shared.js';
@@ -267,6 +268,29 @@ export const tools = [
       required: ['commands'],
     },
   },
+  {
+    name: 'look_at_app',
+    description:
+      'Open the running app in a real browser at a phone width (375px) and a desktop width ' +
+      '(1440px) and report what a person would run into: console errors, failed requests, ' +
+      'content that spills off the side of the screen, broken images, unlabeled buttons and ' +
+      'fields - plus a designer-style review of the screenshots. Use it once the dev server ' +
+      'is ready, and again after visual changes, then fix what it reports. Screenshots are ' +
+      'saved under .ucode/screenshots.',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: str('The local URL the dev server reported, e.g. http://localhost:3000'),
+        paths: {
+          type: 'array',
+          description: 'Pages to open, e.g. ["/", "/settings"]. Defaults to ["/"]. Up to 4.',
+          items: { type: 'string' },
+        },
+        review: bool('Include the visual design review of the screenshots. Defaults to true.'),
+      },
+      required: ['url'],
+    },
+  },
   {
     name: 'web_search',
     description:
@@ -299,6 +323,7 @@ const run = {
   run_command: runCommand,
   run_commands: runCommands,
   web_search: webSearch,
+  look_at_app: lookAtApp,
 };
 
 /** Tools that change the project or execute code. */
@@ -435,6 +460,8 @@ export function describe(name, args = {}) {
       return `Running ${clip(args.command, 70)}${args.background ? ' in the background' : ''}`;
     case 'run_commands':
       return `Running ${args.commands?.length ?? 0} commands together`;
+    case 'look_at_app':
+      return `Looking at ${clip(args.url, 40)} on a phone and a desktop`;
     case 'web_search':
       return `Searching the web for ${clip(args.query, 60)}`;
     case 'load_skill':

package/src/tools/shell.js

@@ -200,7 +200,14 @@ function startServer(command, workdir, { env } = {}) {
         cwd: workdir.abs,
         shell: true,
         windowsHide: true,
-        detached: true,
+        // Not detached on Windows, and this is load-bearing. A detached process
+        // there has no console, and programs launched under it write nothing
+        // to a redirected file — measured: every one of node, npm and next
+        // produced an empty log, so a server's "ready" line never arrived and
+        // every start waited out the full timer. Attached, the output lands.
+        // The server itself still outlives ucode: only this shell is tied to
+        // ucode's job object, and the job lets grandchildren break away.
+        detached: process.platform !== 'win32',
         stdio: ['ignore', fd, fd],
         env,
       });

package/src/ui/screen.js

@@ -39,7 +39,7 @@ import chalk from 'chalk';
 import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
-  shortenPath, asLabel, ensureColour, planLine,
+  shortenPath, asLabel, ensureColour, planLine, bare,
 } from './theme.js';
 import { renderer, render, polish } from './markdown.js';
 import { VERSION } from '../core/version.js';
@@ -773,11 +773,15 @@ export class Screen {
    * cannot be given up permanently, because under alternate scroll the mouse
    * wheel arrives as arrow keys.
    */
-  pick(items, { active = 0, hint = 'enter to choose · esc to cancel' } = {}) {
+  pick(items, { active = 0, hint = 'enter to choose · esc to cancel', deletable = false } = {}) {
     this.picker = {
       items,
       index: Math.min(Math.max(0, active), Math.max(0, items.length - 1)),
       hint,
+      // With deletable, `d` twice on a row resolves { delete: index }. Twice,
+      // because a single stray keypress should never cost a conversation.
+      deletable,
+      armed: null,
     };
     this.render();
     return new Promise((resolve) => { this.pickerResolve = resolve; });
@@ -799,7 +803,7 @@ export class Screen {
    * about instead of a column of near-identical titles.
    */
   pickerLines(height) {
-    const { items, index, hint } = this.picker;
+    const { items, index, hint, armed } = this.picker;
     const room = Math.max(1, height - 2);
 
     // Rows per item, so the window can be sized in rows rather than in items.
@@ -821,12 +825,15 @@ export class Screen {
     for (let i = first; i <= last; i++) {
       const item = items[i];
       const body = typeof item === 'string' ? item : item.label;
-      out.push(i === index ? `${blue('❯')} ${chalk.bold.white(body)}` : `  ${dim(body)}`);
+      if (i === armed) out.push(`${theme.warn('✗')} ${theme.warn(bare(body))}`);
+      else out.push(i === index ? `${blue('❯')} ${chalk.bold.white(body)}` : `  ${dim(body)}`);
       if (typeof item !== 'string' && item.sub) out.push(`  ${item.sub}`);
     }
 
     out.push('');
-    out.push(dim(`  ${hint}`));
+    out.push(armed !== null && armed !== undefined
+      ? theme.warn('  press d again to delete this conversation · any other key keeps it')
+      : dim(`  ${hint}`));
     return out;
   }
 
@@ -932,6 +939,13 @@ export class Screen {
     // An open picker owns the keyboard until it closes.
     if (this.picker) {
       const last = this.picker.items.length - 1;
+      if (this.picker.deletable && (key === 'd' || key === 'D' || key === `${ESC}[3~`)) {
+        if (this.picker.armed === this.picker.index) { this.closePicker({ delete: this.picker.index }); return; }
+        this.picker.armed = this.picker.index;
+        this.render();
+        return;
+      }
+      this.picker.armed = null;   // any other key takes the delete back
       if (key === `${ESC}[A`) { this.picker.index = Math.max(0, this.picker.index - 1); this.render(); return; }
       if (key === `${ESC}[B`) { this.picker.index = Math.min(last, this.picker.index + 1); this.render(); return; }
       if (key === '\r' || key === '\n') { this.closePicker(this.picker.index); return; }
@@ -1149,7 +1163,7 @@ export class Screen {
 
     // The version, in the corner, and nothing else on the screen.
     if (VERSION) {
-      const tag = dim(`v${VERSION}`);
+      const tag = dim(this.facts.update ? `v${VERSION} · v${this.facts.update} installed, starts next time` : `v${VERSION}`);
       frame[this.rows - 1] = ' '.repeat(Math.max(0, g.cols - visLen(tag) - 2)) + tag;
     }