ucode-agent 1.3.0 → 1.5.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,27 +88,43 @@ 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`,
-`edit_file`, `multi_edit`, `edit_files`, `list_dir`, `glob`, `grep`,
-`run_command`, `run_commands`, `web_search`. Read-only calls run in parallel,
+**Fifteen tools.** `create_app`, `read_file`, `read_files`, `write_file`,
+`batch_write`, `edit_file`, `multi_edit`, `edit_files`, `list_dir`, `glob`,
+`grep`, `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.
 
+**Apps start from a ready-made starter.** Setting up Next.js and shadcn from
+nothing takes about four minutes — `create-next-app` and the shadcn CLI measured
+at 116s and 130s — plus a dozen model round trips. `create_app` copies ucode's
+starter instead: Next.js 16, TypeScript, Tailwind 4, shadcn/ui with 25 common
+components, light/dark mode, toasts and a considered theme, already known to
+build. The copy takes under a second, and its install runs in the background
+while the model writes the first components.
+
 **Parallel workers.** When a build splits into parts that touch different files
 — the API route, the upload component, the results view — the model hands them
 to up to three workers that build at the same time, each line in the transcript
@@ -119,6 +135,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 +178,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 +236,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 +275,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.5.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -10,7 +10,8 @@
   "files": [
     "ucode.js",
     "src/",
-    "skills/"
+    "skills/",
+    "templates/"
   ],
   "scripts": {
     "start": "node ucode.js",
@@ -48,6 +49,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

@@ -31,7 +31,25 @@ If there is a user interface, the `ui-ux` skill is already loaded. Decide the
 design direction now, not after the logic works. If the app calls a model,
 load `ai-features`; if it has accounts, keys or uploads, load `security`.
 
-## 2. Scaffold without being asked questions
+## 2. Start from the starter
+
+**For a Next.js app, call `create_app`** — one step, about a second:
+
+```
+create_app({ folder: "my-app", name: "My App", description: "…" })
+```
+
+It copies ucode's ready-made starter — Next.js 16, TypeScript, Tailwind 4,
+shadcn/ui with 25 common components, light/dark mode, toasts, a considered
+theme — which is already known to build, and starts `npm install` in the
+background. Read the `TEMPLATE.md` it lists, then start writing components
+straight away; commands in that folder wait for the install on their own.
+Re-tint the palette in `globals.css` and swap the font for the app's direction.
+
+Never run `create-next-app` or `shadcn init` for a Next.js app — that is
+four minutes and a dozen steps the starter already did.
+
+### Other stacks
 
 Nothing you run has a keyboard. A scaffolder that asks "Would you like to use
 TypeScript?" gets no answer and fails, so give it every answer up front:
@@ -141,8 +159,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');
 }
@@ -223,6 +240,8 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '  one at a time when you already know which ones you want.',
     '- Put independent calls in the same message — several greps, a glob and a read.',
     '  Read-only calls in one message run at the same time.',
+    '- New Next.js app? create_app - one step, never create-next-app or shadcn init. It',
+    '  copies a starter that already builds and installs it in the background.',
     '- batch_write to lay out several new files at once, multi_edit for several changes',
     '  to one file, edit_files for a change that spans several files.',
     '- For work with three or more steps, keep a short plan with update_plan - at most',
@@ -234,6 +253,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 +395,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 +515,7 @@ export class Agent {
   }
 
   async shutdown() {
+    await closeBrowser().catch(() => {});
     this.ui.stopSpinner();
     if (this.session.messages.length) {
       await this.persist();
@@ -559,6 +590,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 +630,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 +709,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 +962,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 +1041,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 +1065,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 +1328,7 @@ export class Agent {
     if (arg) {
       try {
         setModel(arg);
+        this.preferred = model();
       } catch (err) {
         this.ui.error(err, { debug: this.debug });
         return;
@@ -1247,6 +1356,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 +1395,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 +1403,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 +1425,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 +1451,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 +1504,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) {