heartcode 0.1.9 → 0.1.12

package/CHANGELOG.md

@@ -0,0 +1,78 @@
+# Changelog
+
+What changed in each version of HeartCode, newest first.
+
+## 0.1.12 (2026-10-30)
+
+- `auto` is the name for your model list (#1, then the next when one fails); `default` still works.
+- Models are written `provider/model` (`-m groq/openai/gpt-oss-120b`); the old `"provider model"` still works.
+- `heart models` prints what `-m` takes, one per line (`auto` first); `--json` gives an `id` for each.
+- `--fallback-model <provider/model>`, as in `claude -p`: tried after the `-m` model when it fails.
+- Settings changed while HeartCode runs (also `-p`, stream-json and editors over ACP) are taken in
+  without a restart: a new model order from the running task's next request.
+- Settings page: adding a provider, an MCP server or a skill opens a dialog; every dialog is 70% of
+  the screen wide. Your models can be sorted by a provider ranking you drag into order.
+
+## 0.1.11 (2026-10-30)
+
+- A changelog (this file) in place of the old TODO list.
+
+## 0.1.10 (2026-10-30)
+
+- Any model error (a rate limit, an outage, "request too large", a bad model name, a wrong key…)
+  moves on to the next model in your list, another provider's first, without the app using
+  HeartCode seeing it. A run stops with an error only when every model has failed.
+- No more token estimates deciding when to shrink a request or switch models. A long
+  conversation is summarized every 100 messages instead.
+- Settings: the rotation choice "at any error" is gone; it now works the same as "at its first
+  failure".
+
+## 0.1.9 (2026-10-29)
+
+- After an error, the next model tried is from another provider; the failing provider's other
+  models come only after every provider has had a go.
+- Model lists in Cloudflare's format (`{ "result": [...] }`) are read.
+- Settings: model lists no longer stay stuck on "loading…", and an empty saved list is fetched again.
+- A shorter system prompt, with the duplicates taken out.
+
+## 0.1.8 (2026-10-29)
+
+- Settings page: model tests run on the server, long model lists scroll smoothly, prices are
+  shown, and "Test all" shows its progress.
+
+## 0.1.7 (2026-10-29)
+
+- Each request is fitted to the model it goes to (images, tool calls, thinking).
+- Safer file changes.
+- Better handing of work to the other models.
+
+## 0.1.6 (2026-10-29)
+
+- Better handing of work to the other models.
+- A helper's steps are sent to apps using HeartCode, like Claude Code's subagents.
+- Fixed switching models.
+- npm page: GitHub links and keywords.
+
+## 0.1.5 (2026-10-28)
+
+- Several helpers can run at once; thinking is shown with its name; the model lists show what
+  each model can do.
+- Tab only completes, it doesn't send.
+
+## 0.1.3 (2026-10-28)
+
+- Another of your models does what the one in use can't (for example, looking at an image).
+- A path typed at the prompt is no longer taken for a command.
+
+## 0.1.2 (2026-10-28)
+
+- Logging: the size on disk, and a Delete all button.
+- Refresh model data from models.dev.
+- A Test button on the Your models page, a simpler list, and `-latest` model names matched in models.dev.
+- Screenshots in the README.
+
+## 0.1.1 (2026-10-28)
+
+- First release: MCP tools as real tools, fallback models that keep going, a model Test button.
+- The npm package holds only what HeartCode needs to run.
+- README, MIT license, and failures described in SKILL.md.

package/SKILL.md

@@ -14,63 +14,73 @@ answer (or JSON) and exits. Its flags and output match Claude Code's `claude -p`
 ```sh
 heart --version          # installed? (else: node /path/to/heart_cli/bin/heart.js --version)
 heart providers          # the providers set up, and their URLs (keys are masked)
-heart models --json      # the models to pass to -m: "default" first (the user's list, with fallbacks), then each model
-heart models --all --json   # every provider's models too (slower: asks each provider)
+heart models             # what -m takes, one per line: "auto" first, then the user's models (provider/model), #1 first
+heart models --json      # the same, as JSON
+heart models --all       # every provider's models too (slower: asks each provider)
 ```
 
-Read `--json`, not the text: the text layout is for people and may change.
+`heart models` prints one id per line, nothing else (like `opencode models`):
+
+```
+auto
+groq/openai/gpt-oss-120b
+openrouter/qwen/qwen3-coder
+```
+
+With `--json`:
 
 ```json
 { "models": [
-    { "place": null, "provider": null, "model": "default", "role": "default", "rotates": true, "about": "your models in order: #1, then the next when one fails (-m default, or no -m)" },
-    { "place": 1, "provider": "groq", "model": "openai/gpt-oss-120b", "role": "in use", "rotates": false },
-    { "place": 2, "provider": "openrouter", "model": "qwen/qwen3-coder", "role": "fallback", "rotates": false } ],
+    { "id": "auto", "fallbacks": true },
+    { "id": "groq/openai/gpt-oss-120b", "provider": "groq", "model": "openai/gpt-oss-120b", "place": 1 },
+    { "id": "openrouter/qwen/qwen3-coder", "provider": "openrouter", "model": "qwen/qwen3-coder", "place": 2 } ],
   "providers": [
-    { "name": "groq", "baseUrl": "https://api.groq.com/openai/v1", "list": true, "models": ["…"] },
+    { "name": "groq", "baseUrl": "https://api.groq.com/openai/v1", "list": true, "models": ["groq/…"] },
     { "name": "local", "baseUrl": "http://127.0.0.1:9/v1", "list": true, "models": [], "error": "cannot reach …" } ] }
 ```
 
-Each entry in `models` is something to pass to `-m`, in order:
+`id` is exactly what to pass to `-m`:
 
-- **`default`** (always first; `place` and `provider` are `null`): the user's list. `rotates: true`
-  when they have more than one model: #1 is used, and the next one in order when it fails.
-- **the user's models** (`place` 1, 2, …): `role` is `in use` for #1 and `fallback` for the rest;
-  `rotates: false`, since a model named on its own is used alone.
+- **`auto`** (always first): the user's list. `fallbacks: true` when it has more than one model:
+  #1 is used, and the next one in order when it fails. No `-m` means `auto` too. (`default` is
+  its old name and still works.)
+- **the user's models** (`place` 1, 2, …), as `provider/model`: #1 is the one `auto` starts with.
 
 No model set up yet: `models` is empty (and `heart -p` fails with "no model set up").
-`heart models [--all] <filter>` keeps only the entries whose `model` contains `<filter>`.
+`heart models [--all] <filter>` keeps only the ids that contain `<filter>`.
 
 `providers` (only with `--all`): every provider's models. `list: false`: the user switched that
 provider's list off, and `models` are the ones they added by name. A provider that can't be
-reached has an `error` and is skipped; the command still exits `0`.
+reached has an `error` (in text: a line on stderr) and is skipped; the command still exits `0`.
 
 **Which model to pass:**
 
 | `-m` | What runs |
 |---|---|
-| `default`, or no `-m` | the user's list: #1, and the next one in order when it fails (rate limits, outages…). Use this unless you need one particular model. |
-| a model from the list: `-m "<provider> <model>"` (`-m "groq openai/gpt-oss-120b"`), or `-m <model>` alone | that model alone: never another one, also when it fails (a rate limit or an outage is tried again, up to `--max-retries`) |
-
-**Failures:** a rate limit, a server error, a timeout, a reply that stops coming (nothing for 150s),
-a lost connection, or an error page from a proxy in front of the provider is waited out and tried
-again (or handed to the next model in the list), up to `--max-retries` (10). With the default
-list, a model that can't be used (a wrong key, no access to it, a name the server doesn't know:
-401, 403, 404) also makes way for the next one, and so does one that keeps replying with nothing. When a
-provider answers with an error (status 400 or above), the next model tried is from another
-provider; that provider's other models are tried only after every provider has had a go.
-A model that takes over with a smaller context window gets the conversation summarized first, if it
-wouldn't fit.
-The run stops with that error and exit code `1` when every model in the list fails that way, or
-when a single model (`-m <model>`) does. A request a server refuses (400) is sent as it is to two
-more models of the list at most, then the run stops (unless the user set the fallback rule to "at
-any error"). A provider that refuses a part
-of the request HeartCode can do without (the model's thinking sent back, keys in the tools'
-schemas, images) gets it again without that part, and that is remembered for the model for a day.
+| `auto`, or no `-m` | the user's list: #1, and the next one in order when it fails. Use this unless you need one particular model. |
+| `provider/model` (`-m groq/openai/gpt-oss-120b`), or a model of #1's provider alone | that model alone: never another one, also when it fails (a rate limit or an outage is tried again, up to `--max-retries`) |
+| that, plus `--fallback-model provider/model` (repeatable) | that model, then the fallbacks in order when it fails (as `claude -p --fallback-model`) |
+
+**Failures:** with `auto` (the list), any failure (an error status of any kind, a timeout, a reply
+that stops coming, a lost connection, an error page from a proxy, a model that keeps replying with
+nothing) makes way for the next model, from another provider first; that provider's other models
+are tried only after every provider has had a go. None of it shows: the run goes on with the model
+that answers. It stops with exit code `1` only when every model in the list fails: at once if they
+all refused the request outright, else after `--max-retries` (10) whole rounds of them. A single
+model (`-m <model>`) waits out rate limits and outages, up to `--max-retries` tries, and stops at
+any other error. A provider that refuses a part of the request HeartCode can do without (the
+model's thinking sent back, keys in the tools' schemas, images) gets it again without that part,
+and that is remembered for the model for a day. A long conversation is summarized every 100
+messages.
 Each request is fitted to the model it goes to: one that can't see gets a note in place of each
 image, one that can't call tools gets the tool calls as text.
 
 `--provider <name>` and `-u <url>` (a server for this run) also mean one model, alone.
 
+A run picks up settings the user changes meanwhile (`heart settings`, or `~/.heart` by hand)
+without being restarted: a new model order from its next request, MCP servers and skills from its
+next message.
+
 `heart` is installed by `npm start` in the HeartCode folder. `heartcode` is the same command.
 Needs Node.js 20 or newer. No providers? See "Setting up a model" below.
 
@@ -134,8 +144,9 @@ server's tools, `mcp` all of them.
 ## Choose the model
 
 ```sh
-heart -p -m default "…"                         # the user's list, with its fallbacks (the same as no -m)
-heart -p -m "groq openai/gpt-oss-120b" "…"     # that provider and model alone, for this run
+heart -p -m auto "…"                            # the user's list, with its fallbacks (the same as no -m)
+heart -p -m groq/openai/gpt-oss-120b "…"       # that provider and model alone, for this run
+heart -p -m groq/openai/gpt-oss-120b --fallback-model openrouter/qwen/qwen3-coder "…"   # and that one when it fails
 heart -p --provider ollama -m qwen3-coder "…"   # the same, written apart
 heart -p --effort high "…"                      # how hard a thinking model thinks
 ```

package/bin/heartcode.js

@@ -2,9 +2,9 @@
 import path from 'node:path'
 import { parseArgs } from 'node:util'
 import { Client } from '../src/client.js'
-import { loadConfig, saveConfig, readJson, writeJson, providerName, CONFIG_FILE, HOME, DEFAULT_MODEL, VERSION } from '../src/config.js'
+import { loadConfig, saveConfig, readJson, writeJson, providerName, CONFIG_FILE, HOME, AUTO_MODEL, isAuto, parseModel, VERSION } from '../src/config.js'
 import { probe, loadProfile, strategy, describe, profilePath, profileFrom } from '../src/probe.js'
-import { learnFromUsage, RATE_CAP_MS, LIMIT_MS } from '../src/context.js'
+import { learnFromUsage, LIMIT_MS } from '../src/context.js'
 import { Session, transcript } from '../src/agent.js'
 import { treeItems, codePlan, move, leaving, leftText, leftFiles } from '../src/tree.js'
 import { UI, c, PERMISSIONS, rank, setTheme, themeCodes, renderDiff, diffLines, DEFAULT_KEYS, loadKeys } from '../src/ui.js'
@@ -37,8 +37,9 @@ ${c.bold('usage')}
   heart ~/code/my-app                in that folder (a folder, not a file)
   heart "fix the failing test"       run one task and exit
   heart providers                    list added providers
-  heart models [filter]              "default" (your list), then your models: #1 (in use), then its fallbacks
-  heart models --all [filter]        every provider's models, yours marked
+  heart models [filter]              what -m takes, one per line: "auto" (your list), then your models
+                                     as provider/model, #1 first
+  heart models --all [filter]        every provider's models (provider/model)
   heart models --json                as JSON (with --all too), for other programs
   heart probe                        test the current model for real (otherwise its abilities come from models.dev)
   heart config                       show the config file
@@ -46,7 +47,9 @@ ${c.bold('usage')}
 
 ${c.bold('options')}
   -u, --base-url <url>   use this server for this run (add --save to keep it)
-  -m, --model <name>     use this model alone for this run (no fallbacks); "default": your list, with its fallbacks
+  -m, --model <name>     this model alone for this run (provider/model, or a model of #1's provider);
+                         "auto" (the default): your list, #1 then the next when one fails
+      --fallback-model <name>  after -m's model when it fails (repeatable)
       --api-key <key>    API key for --base-url
   -y, --yes              do everything without asking (the default)
       --ask              ask before every edit and command, this run
@@ -61,7 +64,7 @@ ${c.bold('options')}
                          or to continue in it); removed on exit if nothing changed
   -c, --continue         continue the last session in this folder
   -r, --resume [id]      pick an earlier session to continue (or the one with this id)
-      --provider <name>  use this provider for this run (or -m "provider model")
+      --provider <name>  use this provider for this run (or -m provider/model)
 
 ${c.bold('headless')} (for other programs; flags and output as in Claude Code's -p)
   -p, --print                        run without the screen, print the answer, exit
@@ -229,13 +232,12 @@ class App {
         if (name === 'auto_compact' && this.s) this.s.autoCompact = bool
         return save(`${name}: ${bool ? 'on' : 'off'}${name === 'director' ? ' (from the next message)' : ''}`)
       case 'model': {
-        let [p, ...m] = v.split(/\s+/)
-        if (!cfg.providers[p]) [p, m] = [cfg.provider, [v]]
-        if (!cfg.providers[p] || !m.join(' ')) return `error: give "provider model" or a model of the current provider; providers: ${Object.keys(cfg.providers).join(', ')}`
+        const { provider: p, model: m } = parseModel(v, cfg.providers, cfg.provider)
+        if (!cfg.providers[p] || !m) return `error: give provider/model or a model of the current provider; providers: ${Object.keys(cfg.providers).join(', ')}`
         // headless (-p) and editors (ACP): the program that started HeartCode chooses the model
         if (this.ui instanceof HeadlessUI) return 'error: the model can\'t be switched here: the program that started HeartCode chooses it'
-        this.later.push(() => this.use(p, m.join(' ')).catch((e) => ui.warn(e.message)))
-        return `switching to ${p} · ${m.join(' ')} after this reply`
+        this.later.push(() => this.use(p, m).catch((e) => ui.warn(e.message)))
+        return `switching to ${p} · ${m} after this reply`
       }
       default:
         return `error: no setting "${name}"; manage list kind setting shows them`
@@ -313,14 +315,6 @@ class App {
       if (change) log('context', `${change}: ${used} tokens counted, ~${estimate} estimated; window now ${strategy(profile, cfg).context}`, { was, largestAccepted: profile.largestAccepted, inputLimit: profile.inputLimit, tokenRatio: profile.tokenRatio })
       if (change) learned()
     }
-    // The server said "too large" with its limit: remembered for this model (also next time). A
-    // per-minute cap is your account's at this provider: kept apart, for a day.
-    client.onInputLimit = (n, { rate = false } = {}) => {
-      if (rate) profile.rateCap = { tokens: n, until: Date.now() + RATE_CAP_MS }
-      else Object.assign(profile, { inputLimit: Math.min(profile.inputLimit ?? Infinity, n), inputLimitAt: Date.now() })
-      learned()
-      ui.warn(rate ? `${client.provider} takes at most ~${n} tokens a minute on your account; shortening the conversation to fit (for today)` : `${client.model} takes at most ~${n} tokens per request here; shortening the conversation to fit`)
-    }
     // models.dev's published size for the model (a day old at most): used when the server doesn't say
     loadPrices().then(() => {
       price = priceOf(client.provider, client.baseUrl, client.model)
@@ -646,11 +640,11 @@ class App {
   }
 
   // The model list (settings page): this model first, then the others in order; set on the session.
-  // A model given for this run (-m, not "default") is used alone: no fallbacks (cfg.fixed).
+  // A model given for this run (-m, not "auto") is used alone (cfg.fixed), then --fallback-model's.
   useRotation() {
     const { cfg } = this
     const seen = new Set()
-    const list = [{ provider: cfg.provider, model: cfg.model }, ...(cfg.fixed ? [] : (cfg.rotation?.then ?? []))]
+    const list = [{ provider: cfg.provider, model: cfg.model }, ...(cfg.fixed ? [] : (cfg.rotation?.then ?? [])), ...(cfg.fallbacks ?? [])]
       .filter((t) => cfg.providers[t.provider] && t.model && !seen.has(`${t.provider}/${t.model}`) && seen.add(`${t.provider}/${t.model}`))
       .map((t) => ({ ...t, baseUrl: cfg.providers[t.provider].baseUrl, apiKey: cfg.providers[t.provider].apiKey }))
     this.s?.client.setRotation(list, cfg.rotation ?? {})
@@ -744,19 +738,16 @@ class App {
     }
   }
 
-  // `heart models`: your models, in order (every provider's whole list is on the settings page).
-  // all: every provider's models too (fetched from each; a provider whose list is switched off: the
-  // ones added by name), yours marked. json: one JSON object on stdout, for other programs:
-  //   { "models": [{ "place": null, "provider": null, "model": "default", "role": "default", "rotates": true, "about": "…" },
-  //                { "place": 1, "provider", "model", "role": "in use" | "fallback", "rotates": false }, …],
-  //     "providers": [{ "name", "baseUrl", "list": true, "models": ["…"], "error"? }] }   (--all)
-  // "default" is the name for your list: -m default (or no -m) uses #1 and moves on to the next when
-  // one fails; -m with one of the models is that model alone.
+  // `heart models`: what -m takes, one per line (as \`opencode models\`): "auto" (your list: #1, then
+  // the next when one fails; also no -m), then your models as provider/model, #1 first. all: every
+  // provider's models (fetched from each; a provider whose list is off: the ones added by name).
+  // json: one JSON object on stdout, for other programs:
+  //   { "models": [{ "id": "auto", "fallbacks": true }, { "id": "groq/openai/gpt-oss-120b", "provider", "model", "place": 1 }, …],
+  //     "providers": [{ "name", "baseUrl", "list": true, "models": ["provider/model", …], "error"? }] }   (--all)
   async listModels(filter = '', { all = false, json = false } = {}) {
     const { ui, cfg } = this
     const match = (id) => id.toLowerCase().includes(filter.toLowerCase())
-    const mine = this.myModels().map((t, i) => ({ place: i + 1, provider: t.provider, model: t.model, role: i === 0 ? 'in use' : 'fallback', rotates: false }))
-    const placeOf = (provider, model) => mine.find((t) => t.provider === provider && t.model === model)?.place
+    const mine = this.myModels().map((t, i) => ({ id: `${t.provider}/${t.model}`, provider: t.provider, model: t.model, place: i + 1 }))
     const providers = !all ? [] : await Promise.all(Object.entries(cfg.providers).map(async ([name, p]) => {
       const out = { name, baseUrl: p.baseUrl, list: p.list !== false, models: [] }
       if (out.list) {
@@ -767,32 +758,17 @@ class App {
         }
       }
       // and the ones added by name, and any of yours it doesn't list (as on the settings page)
-      out.models = [...new Set([...out.models, ...(p.models ?? []), ...mine.filter((t) => t.provider === name).map((t) => t.model)])].sort((a, b) => a.localeCompare(b)).filter(match)
+      out.models = [...new Set([...out.models, ...(p.models ?? []), ...mine.filter((t) => t.provider === name).map((t) => t.model)])].sort((a, b) => a.localeCompare(b)).map((id) => `${name}/${id}`).filter(match)
       return out
     }))
-    // "default" first, in the same list: your models, rotating (when there's any)
-    const about = mine.length > 1 ? `your models in order: #1, then the next when one fails (-m ${DEFAULT_MODEL}, or no -m)` : `your one model, #1 (-m ${DEFAULT_MODEL}, or no -m)`
-    const first = mine.length ? [{ place: null, provider: null, model: DEFAULT_MODEL, role: 'default', rotates: mine.length > 1, about }] : []
-    const shown = [...first, ...mine].filter((t) => match(t.model))
-    if (json) {
-      process.stdout.write(JSON.stringify({ models: shown, ...(all && { providers }) }, null, 2) + '\n')
-      return
-    }
+    const shown = [...(mine.length ? [{ id: AUTO_MODEL, fallbacks: mine.length > 1 }] : []), ...mine].filter((t) => match(t.id))
+    if (json) return void process.stdout.write(JSON.stringify({ models: shown, ...(all && { providers }) }, null, 2) + '\n')
     if (!all) {
-      if (!shown.length) return ui.print(filter ? `None of your models matches "${filter}".` : NO_MODELS)
-      for (const t of shown) ui.print(t.place === null ? `${c.magenta('●')} ${c.bold(t.model)} ${c.dim(t.about)}` : `  ${c.bold(`#${t.place}`)} ${t.model} ${c.dim(`${t.provider} · ${t.role}; alone with -m "${t.provider} ${t.model}"`)}`)
-      return
-    }
-    if (!providers.length) return ui.print(NO_MODELS)
-    for (const p of providers) {
-      ui.print(`${c.bold(p.name)}  ${c.dim(p.baseUrl)}${p.list ? '' : c.dim('  (its list is off: the models added by name)')}`)
-      if (p.error) ui.print(`  ${c.red("can't list its models:")} ${c.dim(p.error)}`)
-      if (!p.models.length && !p.error) ui.print(c.dim(filter ? `  none matches "${filter}"` : '  no models'))
-      for (const id of p.models) {
-        const at = placeOf(p.name, id)
-        ui.print(`  ${at === 1 ? c.magenta('●') : ' '} ${id}${at ? `  ${c.bold(`#${at}`)} ${c.dim(at === 1 ? 'in use' : 'fallback')}` : ''}`)
-      }
+      if (!mine.length) return ui.print(NO_MODELS)
+      return void process.stdout.write(shown.map((t) => t.id + '\n').join(''))
     }
+    for (const p of providers) if (p.error) process.stderr.write(`heartcode: can't list ${p.name}'s models: ${p.error}\n`)
+    process.stdout.write(providers.flatMap((p) => p.models).map((id) => id + '\n').join(''))
   }
 }
 
@@ -876,8 +852,9 @@ function openBrowser(url) {
   spawnSync(cmd, args, { stdio: 'ignore' })
 }
 
-// A change on the settings page (in cfg, saved), brought into every open tab: right away, or the
-// model and MCP servers after the reply in progress.
+// A change on the settings page (in cfg, saved), brought into every open tab and run (also -p and
+// ACP): right away, the model list too (the running task's next request goes to the new #1); MCP
+// servers and skills after the reply in progress.
 function applySettings(apps, cfg, what) {
   const before = themeCodes()
   if (what === 'theme' || what === 'setting:theme') setTheme(cfg.theme)
@@ -887,18 +864,20 @@ function applySettings(apps, cfg, what) {
   settingsSeen(what) // the watcher (watchSettings) mustn't take it in a second time
   for (const app of apps) {
     const { ui } = app
-    const busy = Boolean(ui.busySince)
+    const busy = Boolean(ui.busySince || app.working)
     const now = (fn) => (busy ? app.later.push(fn) : fn())
     if (app.cfg !== cfg) for (const k of ['providers', 'provider', 'model', 'effort', 'theme', 'context', 'autoCompact', 'director', 'format', 'lsp', 'voice', 'rotation']) app.cfg[k] = cfg[k]
     if (what === 'model') {
       app.lists = {}
       delete app.cfg.fixed // a model chosen on the page: your list again
-      const want = cfg.providers[cfg.provider] && app.client(cfg.provider, cfg.model)
-      if (app.s && !(want && ['model', 'baseUrl', 'apiKey'].every((k) => want[k] === app.s.client[k])))
-        now(() => {
-          app.s = null
-          ui.print(c.dim(cfg.model ? `settings: ${cfg.provider} · ${cfg.model} from the next message` : 'settings: no model chosen'))
-        })
+      if (app.s && !(cfg.providers[cfg.provider] && cfg.model)) now(() => ((app.s = null), ui.print(c.dim('settings: no model chosen'))))
+    }
+    // your model list: into the running session now, its next request goes to the new #1
+    if ((what === 'model' || what === 'setting:rotation') && app.s && cfg.providers[cfg.provider] && cfg.model) {
+      const was = `${app.s.client.provider} · ${app.s.client.model}`
+      app.useRotation()
+      const is = `${app.s.client.provider} · ${app.s.client.model}`
+      if (is !== was) ui.print(c.dim(`settings: ${is} now`))
     }
     if (what === 'provider') app.lists = {} // its list switched on or off, a model added by name
     if (what === 'setting:permissions') ui.setPermission(cfg.permissions)
@@ -906,21 +885,11 @@ function applySettings(apps, cfg, what) {
     if (what === 'setting:autoCompact' && app.s) app.s.autoCompact = cfg.autoCompact !== false
     if (what === 'setting:format' && app.s) app.s.noFormat = cfg.format === false
     if (what === 'setting:lsp' && app.s) app.s.noLsp = cfg.lsp === false
-    if (what === 'setting:context') now(() => (app.s = null))
-    if (what === 'model' || what === 'setting:rotation') now(() => app.useRotation())
+    // the window size, or a model set up or measured on the page: the model in use takes it again
+    // from its profile now (it saves its profile as it learns, so it mustn't keep the old one)
+    if ((what === 'setting:context' || what === 'profile') && app.s) app.s.client.onUse?.({ provider: app.s.client.provider, model: app.s.client.model })
     if (what === 'mcp' || what === 'skill') now(() => app.reload(what))
     if (what === 'keys') ui.keys = { ...DEFAULT_KEYS, ...loadKeys() }
-    // a model set up or measured on the page: into the session's profile now (it saves its profile
-    // as it learns, so it mustn't keep the old one); its mode from the next message
-    if (what === 'profile' && app.s?.profile) {
-      const disk = loadProfile({ baseUrl: app.s.profile.baseUrl, model: app.s.profile.model })
-      if (disk) {
-        for (const k of ['source', 'set', 'known', 'measured', 'measuredAt']) disk[k] === undefined ? delete app.s.profile[k] : (app.s.profile[k] = disk[k])
-        const st = strategy(app.s.profile, app.cfg)
-        Object.assign(app.s.strat, (({ context, contextSure, reply }) => ({ context, contextSure, reply }))(st))
-        if (st.actions !== app.s.strat.actions || st.thinking !== app.s.strat.thinking || st.vision !== app.s.strat.vision || st.stream !== app.s.strat.stream) now(() => (app.s = null))
-      }
-    }
     if (what === 'theme' || what === 'setting:theme') ui.recolor(before, themeCodes())
     else ui.render()
   }
@@ -1436,6 +1405,7 @@ async function main() {
     options: {
       'base-url': { type: 'string', short: 'u' },
       model: { type: 'string', short: 'm' },
+      'fallback-model': { type: 'string', multiple: true },
       'api-key': { type: 'string' },
       yes: { type: 'boolean', short: 'y' },
       ask: { type: 'boolean' },
@@ -1495,8 +1465,12 @@ async function main() {
     if (!cfg.providers[f.provider]) throw new Error(`no provider "${f.provider}" (heartcode providers lists them)`)
     Object.assign(cfg, { provider: f.provider, fixed: true })
   }
-  const [p0, ...rest] = String(f.model ?? '').split(/\s+/) // -m "groq openai/gpt-oss-120b"
-  if (rest.length && cfg.providers[p0]) Object.assign(cfg, { provider: p0, model: rest.join(' ') })
+  // --fallback-model: after the model given (as in Claude Code's -p), when it fails
+  cfg.fallbacks = (f['fallback-model'] ?? []).map((v) => {
+    const t = parseModel(v, cfg.providers, cfg.provider)
+    if (isAuto(v) || !cfg.providers[t.provider]) throw new Error(`--fallback-model ${v}: give provider/model, or a model of ${cfg.provider} (heart models lists yours)`)
+    return t
+  })
   if (f.effort) cfg.effort = f.effort === 'default' ? undefined : f.effort
   if (f['mcp-config'] || f['strict-mcp-config']) cfg.mcp = { extra: f['mcp-config'] ?? [], strict: Boolean(f['strict-mcp-config']) }
   extraSkillDirs.push(...(f['skills-dir'] ?? []).map((d) => path.resolve(d)))
@@ -1524,7 +1498,9 @@ async function main() {
     // each editor session gets its own App, for its folder and its MCP servers
     cfg.maxRetries ??= 10
     // each editor session its own settings (one choosing a model doesn't change the others')
-    const makeApp = (root, ui, mcp) => new App({ ...structuredClone(cfg), ...(mcp && { mcp: { extra: [mcp] } }) }, ui, root)
+    const apps = []
+    const makeApp = (root, ui, mcp) => apps[apps.push(new App({ ...structuredClone(cfg), ...(mcp && { mcp: { extra: [mcp] } }) }, ui, root)) - 1]
+    watchSettings(() => apps, cfg) // the settings page's changes, into every editor session
     process.exit(await runAcp({ makeApp, version: VERSION, permission: f['permission-mode'] ? PERMISSION_MODES[f['permission-mode']] : (cfg.permissions ?? 'ask') }))
   }
   const headless = f.print || f['output-format'] || f['input-format'] === 'stream-json'
@@ -1608,6 +1584,7 @@ async function main() {
   const chat = f['resume-id'] ? loadChat(f['resume-id']) : f.continue && headless ? listChats(app.root)[0] : f['session-id'] ? (loadChat(f['session-id']) ?? { ...newChat(app.root), id: f['session-id'] }) : null
   if (f['resume-id'] && !chat) throw new Error(`no session ${f['resume-id']}`)
   if (chat && (headless || !f['resume-id'])) app.setChat(chat) // interactive: resumed below, with its transcript
+  if (headless || positionals.length) watchSettings(() => [app], cfg) // an app's run takes the settings page's changes too
   if (headless) {
     app.allowTools = [...(f.allowedTools ?? []), ...(f['allowed-tools'] ?? [])]
     app.denyTools = [...(f.disallowedTools ?? []), ...(f['disallowed-tools'] ?? [])]
@@ -1621,7 +1598,7 @@ async function main() {
     await leaveWorktree(app)
     process.exit(ok ? 0 : 1) // MCP servers are stopped by the exit hooks
   }
-  watchSettings(() => [app], cfg)
+  if (!positionals.length) watchSettings(() => [app], cfg)
   await repl(app, f)
   await leaveWorktree(app)
   process.exit(process.exitCode ?? 0) // /exit or Ctrl+D: quit, even if a timer or an MCP server is still around

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heartcode",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "A coding CLI for any local or OpenAI-compatible model, including small models without tool calling.",
   "keywords": [
     "ai",

package/src/acp.js

@@ -126,16 +126,22 @@ export async function runAcp({ makeApp, version, permission = 'ask', input = pro
       const { text, images } = promptOf(prompt, app.root)
       it.ctl = new AbortController()
       app.signal = it.ctl.signal
+      app.working = true // settings changed meanwhile: MCP servers and skills wait for the end of it
       try {
+        const s = app.s ?? (await app.session()) // a model chosen again on the settings page
+        if (!s) throw Object.assign(new Error('no model set up: run heart settings to add a provider and choose a model'), { code: -32000 })
+        s.onEvent ??= (e) => events(it.ui, s, e)
         const k = /^\/(\S+)\s*([\s\S]*)$/.exec(text)
         const skill = k && app.skills.get(k[1])
-        await app.s.run(skill && skill.use !== 'model' ? await app.expandSkill(skill, k[2]) : text, it.ctl.signal, images)
+        await s.run(skill && skill.use !== 'model' ? await app.expandSkill(skill, k[2]) : text, it.ctl.signal, images)
         return { stopReason: 'end_turn' }
       } catch (e) {
         if (it.ctl.signal.aborted) return { stopReason: 'cancelled' }
         if (e.maxTurns) return { stopReason: 'max_turn_requests' }
         throw e
       } finally {
+        app.working = false
+        app.afterLine?.()
         it.ctl = null
         it.ui.calls = []
         app.save()

package/src/agent.js

@@ -104,7 +104,7 @@ export class Session {
     const body = native ? chat.messages.slice(head.length) : []
     const conversation = native ? transcript(body) : chat.history.map((h) => `User: ${h.task}\nAssistant: ${h.answer}`).join('\n\n')
     if (!conversation.trim()) return null
-    let room = Math.floor((strat.context * 0.6 * 3.5) / (strat.ratio ?? 1)) // characters of conversation the summary request can carry
+    const room = Math.floor((strat.context * 0.6 * 3.5) / (strat.ratio ?? 1)) // characters of conversation the summary request can carry
     const cut = () => (conversation.length > room ? `[… the earliest part is cut]\n${conversation.slice(-room)}` : conversation)
     const before = native ? size(body) : est(conversation)
     ui.spinner(midTask ? 'context almost full: compacting the conversation' : 'compacting the conversation')
@@ -114,17 +114,7 @@ export class Session {
     const request = (extra) => prompt('compact/summarize', { conversation: cut(), focus }) + extra
     const send = (extra) =>
       client.chat({ messages: strat.mergeSystem ? [{ role: 'user', content: `${prompt('compact/summarizer')}\n\n${request(extra)}` }] : [{ role: 'system', content: prompt('compact/summarizer') }, { role: 'user', content: request(extra) }] }, { signal })
-    // too large even for the summary request: send less of it (the newest part) until it fits
-    const ask = async (extra = '') => {
-      for (;;) {
-        try {
-          return await send(extra)
-        } catch (e) {
-          if (!e.inputLimit || room < 2000) throw e
-          room = Math.floor(Math.min(room, (e.inputLimit * 3.5) / (strat.ratio ?? 1)) * 0.7)
-        }
-      }
-    }
+    const ask = (extra = '') => send(extra)
     let summary = notSummary((await ask()).content)
     if (!summary) {
       log('compact', 'the reply was not a summary; asking again')
@@ -603,18 +593,12 @@ async function runNative(s, task, images, signal) {
     s.messages.push({ role: 'user', content: s.chat.branchNote }, { role: 'assistant', content: prompt('compact/acknowledged') })
     delete s.chat.branchNote
   }
-  let shrink = 1 // drops when the server says a request is too large
   s.compactedAt = -1
-  // What may be sent: the window less a tenth (estimates are estimates) and less room for the
-  // reply (the longest the model gives, from models.dev, at most a quarter of the window; 8k when
-  // unknown) and the tools; trimming keeps to it. Auto-compact starts at 90% of it, so it comes
-  // before any trimming.
-  // s.sizeCap: "too large" without the server saying its limit: a guess for this conversation only
-  const windowSize = () => Math.min(strat.context, s.sizeCap ?? Infinity)
-  const reply = () => Math.min(strat.reply || 8192, Math.floor(windowSize() * 0.25))
-  const budget = () => Math.floor(((windowSize() * 0.9 - reply()) * shrink) / (strat.ratio ?? 1)) - 800 // in estimated tokens
-  const nearlyFull = () => s.autoCompact && s.messages.length > 3 && size(s.messages) > budget() * 0.9
-  // Already near full from earlier messages: compact first, so the new message stays word for word.
+  // Auto-compact: every 100 messages, the conversation is summarized (what fits each model is
+  // models.dev's business and the model list's: one that fails, the next takes over)
+  const COMPACT_AT = 100
+  const nearlyFull = () => s.autoCompact && s.messages.length >= COMPACT_AT + (s.compactFailedAt ?? 0)
+  // Already that long from earlier messages: compact first, so the new message stays word for word.
   if (nearlyFull()) {
     await s.compact({ signal }).catch((e) => (e.name === 'AbortError' ? Promise.reject(e) : ui.warn(`could not compact: ${e.message}`)))
   }
@@ -657,17 +641,17 @@ async function runNative(s, task, images, signal) {
       ui.warn(`stopped after ${s.maxTurns} steps (--max-turns); say "continue" to go on`)
       throw Object.assign(new Error(`stopped after ${s.maxTurns} steps (--max-turns)`), { maxTurns: true })
     }
-    // after a failed compaction, the next try waits until the conversation grew by a fifth
-    if (nearlyFull() && s.messages.length > 4 && step !== s.compactedAt && size(s.messages) > (s.compactFailedAt ?? 0) * 1.2) {
+    // after a failed compaction, the next try waits for 20 more messages
+    if (nearlyFull() && step !== s.compactedAt) {
       s.compactedAt = step
-      await s.compact({ signal, midTask: true, task }).catch((e) => {
-        if (e.name === 'AbortError') throw e
-        // no summary: free the space anyway, by shortening older tool output and dropping the oldest turns
-        fitMessages(s.messages, Math.floor(budget() * 0.5))
-        s.compactFailedAt = size(s.messages)
-        ui.warn(`could not compact (${e.message}); shortened older tool output and messages instead`)
-        log('compact', `failed (${e.message}); trimmed to ~${s.compactFailedAt} tokens`)
-      })
+      await s.compact({ signal, midTask: true, task }).then(
+        () => (s.compactFailedAt = 0),
+        (e) => {
+          if (e.name === 'AbortError') throw e
+          s.compactFailedAt = (s.compactFailedAt ?? 0) + 20
+          log('compact', `failed (${e.message}); trying again 20 messages later`)
+        },
+      )
     }
     // what the user typed while it worked goes in before the next step (steering)
     const added = step && !s.isSub ? (ui.takeAhead?.() ?? []) : []
@@ -679,31 +663,13 @@ async function runNative(s, task, images, signal) {
     // the model answering can change mid-message (your model list): the system prompt follows it
     const now = SYSTEM(s)
     if (s.messages[0]?.content !== now && (s.messages[0]?.role === 'system' || strat.mergeSystem)) s.messages[0] = { ...s.messages[0], content: now }
-    fitMessages(s.messages, budget())
     pairTools(s.messages)
     ui.spinner('thinking')
     const out = ui.response(client.model) // named: helpers think too (theirs are named in helperUI)
     const stream = strat.toolsStream
-    let res
-    try {
-      // A long tool call (a whole file) streams in silently: say what's being written.
-      const onToolDelta = (name, args) => ui.spinner(`${name === 'run_command' ? 'preparing a command' : `writing ${/"path"\s*:\s*"([^"]+)"/.exec(args)?.[1] ?? name}`} · ${args.length >= 1000 ? `${(args.length / 1000).toFixed(1)}k` : args.length} chars`)
-      res = await client.chat({ messages: s.messages, tools, stream }, { signal, onToken: out.text, onReasoning: out.think, onToolDelta })
-    } catch (e) {
-      if (!e.inputLimit || shrink < 0.3) throw e
-      // what every request carries (the system prompt and the tools) is over the limit already: no
-      // shorter conversation fits (a per-minute cap smaller than that), so not tried again
-      const fixed = Math.round((est(JSON.stringify(tools)) + sizeOf(s.messages[0])) * (strat.ratio ?? 1))
-      if (fixed >= e.inputLimit) throw Object.assign(e, { message: `${e.message} (the system prompt and tools alone are ~${fixed} tokens: this can't fit)` })
-      out.end()
-      // e.fitted: the next model's window is smaller (strat already follows it): compacted at once
-      if (!e.fitted) {
-        s.sizeCap = Math.min(s.sizeCap ?? Infinity, e.inputLimit)
-        shrink *= 0.8 // strat.context already dropped to the limit; leave more headroom each time
-      }
-      step--
-      continue
-    }
+    // A long tool call (a whole file) streams in silently: say what's being written.
+    const onToolDelta = (name, args) => ui.spinner(`${name === 'run_command' ? 'preparing a command' : `writing ${/"path"\s*:\s*"([^"]+)"/.exec(args)?.[1] ?? name}`} · ${args.length >= 1000 ? `${(args.length / 1000).toFixed(1)}k` : args.length} chars`)
+    const res = await client.chat({ messages: s.messages, tools, stream }, { signal, onToken: out.text, onReasoning: out.think, onToolDelta })
     ui.stopSpin()
     if (!stream) {
       out.think(res.reasoning)

package/src/client.js

@@ -164,7 +164,8 @@ export class Client {
   // 'stay' on the one that worked). onSwitch(target): a different model answered than before.
   setRotation(list, { on = 'failure', retries = 2, next = 'first' } = {}) {
     if (!list || list.length < 2) {
-      if (this.rotation) this.#use(this.rotation.list[0])
+      const t = list?.[0] ?? this.rotation?.list[0] // one model: that one (a new #1 from the settings page too)
+      if (t && (t.model !== this.model || normalizeBaseUrl(t.baseUrl) !== this.baseUrl || t.apiKey !== this.apiKey)) this.#use(t)
       this.rotation = null
       return
     }
@@ -228,7 +229,8 @@ export class Client {
   #rotate(e, tries, pick) {
     const r = this.rotation
     if (!r) return false
-    if (!(r.on === 'any' || (r.on === 'failure' && (outage(e) || unusable(e))) || (r.on === 'retries' && (tries >= r.retries || unusable(e))))) return false
+    // at any failure; "after retries": a failure waiting can fix (a rate limit, an outage) is tried again first
+    if (r.on === 'retries' && outage(e) && tries < r.retries) return false
     r.at = pick ? pick() : (r.at + 1) % r.list.length
     log('rotate', `${e.message.slice(0, 200)} → ${r.list[r.at].provider} · ${r.list[r.at].model}`)
     this.#use(r.list[r.at])
@@ -400,40 +402,16 @@ export class Client {
   // 60s, or the server's Retry-After) until it works or the signal aborts. onRetry(error, ms,
   // attempt) reports each wait; onRetry(null) reports the recovery.
   async chat(body, opts = {}) {
-    // "too large": never retried as is; the limit is learned and the caller sends less
-    const tooLarge = (e) => {
-      const limit = inputLimit(e, Math.round(estMessages(body.messages) * this.tokenRatio), this.knownGood)
-      if (!limit) return false
-      e.inputLimit = limit // this request is sent smaller
-      // remembered only when the server said the number (a guess isn't); a per-minute cap apart
-      const said = limitSaid(e)
-      log('limit', `request too large; ${said ? `the server says ${said.tokens}${said.rate ? ' per minute' : ''}` : `no limit given, trying ~${limit}`}`)
-      if (said) this.onInputLimit?.(said.tokens, { rate: said.rate })
-      return true
-    }
     if (!this.onRetry) {
-      try {
-        return await this.#timed(body, opts)
-      } catch (e) {
-        tooLarge(e)
-        throw e
-      }
+      return await this.#timed(body, opts)
     }
     let tries = 0 // of the model being tried now
     let round = 0 // models tried since the last wait (a whole round of them failing: a short pause)
     let hard = true // every failure in this round was one that waiting can't fix (see outage)
-    let refusedBy = 0 // models that refused this request (a bad request), tried in turn
+    let rounds = 0 // whole rounds of the list that failed
     const tried = new Set() // places in the model list tried for this request
     const down = new Set() // providers that answered it with an error (400 or above): their other models are skipped
-    const first = this.target
     for (let attempt = 0; ; attempt++) {
-      // moved on to a model with a smaller window than the conversation was fitted to: handed back
-      // (as "too large", at that window) so the caller summarizes it first, instead of a refusal
-      const sent = this.target !== first && body.messages && this.can?.context && Math.round(estMessages(body.messages) * this.tokenRatio)
-      if (sent > this.can.context * 0.9) {
-        log('limit', `${this.model}: ~${sent} tokens don't fit its window (${this.can.context}); handed back to be made smaller`)
-        throw Object.assign(new Error(`the conversation (~${sent} tokens) is too large for ${this.model} (${this.can.context})`), { inputLimit: this.can.context, fitted: true })
-      }
       try {
         const r = await this.#timed(body, { ...opts, once: true })
         if (attempt) this.onRetry(null)
@@ -442,22 +420,11 @@ export class Client {
         return r
       } catch (e) {
         if (e.name === 'AbortError' || opts.signal?.aborted) throw e
-        if (tooLarge(e)) throw e // the caller shrinks the conversation and sends again
         this.onFail?.(e, { provider: this.provider, model: this.model }) // counted for orchestration
-        if (this.retryIf && !this.retryIf(e, attempt)) throw e
-        // A bad request (400…) with a list of models: the next one may take it (it's often what the
-        // conversation holds from another model). Two more at most, then it stops.
-        if (!outage(e) && !unusable(e) && this.rotation && this.rotation.on !== 'any' && refusedBy < Math.min(2, this.rotation.list.length - 1)) {
-          refusedBy++
-          this.#next(`refused (${e.status})`, () => this.#pick(e, tried, down))
-          this.onRetry(e, 0, attempt + 1, this.target)
-          continue
-        }
-        // A bad request (400…): the same request fails the same way every time, so it isn't sent
-        // again. It stops here, unless the model list moves on at any error (the settings page). A
-        // model that can't be used (a wrong key or name: 401, 403, 404) makes way for the next one
-        // in the list; a whole round of those stops too, rather than going round.
-        if (!outage(e) && !(unusable(e) && this.rotation) && this.rotation?.on !== 'any') throw e
+        // With a list of models, any failure makes way for the next one (another provider's first).
+        // Without one, only what waiting can fix is tried again.
+        if (!(this.rotation?.list.length > 1) && !outage(e)) throw e
+        if (this.retryIf && !this.retryIf(e, tries)) throw e // headless: --max-retries for one model
         hard &&= !outage(e)
         tries++
         if (this.#rotate(e, tries, () => this.#pick(e, tried, down))) {
@@ -466,6 +433,7 @@ export class Client {
           // requests a minute); the user chose "round again at once"
           if (++round >= this.rotation.list.length) {
             if (hard) throw e // every model refused it outright: going round again won't change that
+            if (this.retryIf && !this.retryIf(e, ++rounds)) throw e // headless: --max-retries whole rounds
             hard = true
             round = 0
             this.onRetry(e, 1000, attempt + 1, this.target)

package/src/config.js

@@ -72,9 +72,22 @@ function fromFile() {
 // cfg: { providers: {name: {baseUrl, apiKey}}, provider, model, context, adhoc }
 // flags > env > ~/.heart/config.json. A URL from flags or env becomes a provider for this run
 // only (cfg.adhoc), unless saved.
-// The model name that means your list: #1, then the fallbacks when one fails (also: no model given).
-// Any other model given for a run (-m, HEART_MODEL, a URL of its own) is that model alone: fixed.
-export const DEFAULT_MODEL = 'default'
+// The model name that means your list: #1, then the next when one fails (also: no model given;
+// "default" is its old name). Any other model given for a run (-m, HEART_MODEL, a URL of its own)
+// is that model alone: fixed (--fallback-model adds others after it).
+export const AUTO_MODEL = 'auto'
+export const isAuto = (m) => m === AUTO_MODEL || m === 'default'
+
+// A model as given (-m, --fallback-model, /model): "provider/model" (as opencode writes it; split at
+// the first "/", provider names have none), the older "provider model", or a model of `current`.
+export function parseModel(v, providers, current) {
+  v = String(v).trim()
+  const spaced = /^(\S+)\s+(.+)$/.exec(v)
+  if (spaced && providers[spaced[1]]) return { provider: spaced[1], model: spaced[2] }
+  const i = v.indexOf('/')
+  if (i > 0 && providers[v.slice(0, i)]) return { provider: v.slice(0, i), model: v.slice(i + 1) }
+  return { provider: current, model: v }
+}
 
 // providers by name, A to Z: every list of them (settings page, `heart providers`, pickers) follows
 export const byName = (providers) => Object.fromEntries(Object.entries(providers ?? {}).sort(([a], [b]) => a.localeCompare(b, undefined, { sensitivity: 'base' })))
@@ -98,7 +111,7 @@ export function loadConfig(flags = {}) {
     cfg.providers[cfg.provider].apiKey = apiKey
   }
   const model = flags.model || process.env.HEART_MODEL
-  if (model && model !== DEFAULT_MODEL) Object.assign(cfg, { model, fixed: true })
+  if (model && !isAuto(model)) Object.assign(cfg, parseModel(model, cfg.providers, cfg.provider), { fixed: true })
   return cfg
 }
 

package/src/guided.js

@@ -225,14 +225,8 @@ class Guided {
 
   // `answer: true` streams the reply to the user as the answer; otherwise only thinking is shown.
   // room: tokens of context to keep free for the reply (only for fitting the context; never sent).
-  async query(question, opts = {}, tries = 0) {
-    try {
-      return await this.ask1(question, opts, tries)
-    } catch (e) {
-      // too large for the model: strat.context has dropped to its limit, so the context shrinks
-      if (!e.inputLimit || tries >= 3) throw e
-      return this.query(question, opts, tries + 1)
-    }
+  query(question, opts = {}) {
+    return this.ask1(question, opts)
   }
 
   async ask1(question, { room = 32, schema, oneLine, onToken, answer, skipKey } = {}, tries = 0) {

package/src/headless.js

@@ -150,6 +150,7 @@ export async function runHeadless(app, opts) {
     said = false
     current = { ctl: new AbortController() }
     app.signal = current.ctl.signal
+    app.working = true // settings changed meanwhile: MCP servers and skills wait for the end of it
     let answer = ''
     let error = null
     try {
@@ -162,6 +163,8 @@ export async function runHeadless(app, opts) {
       log('error', error, e.stack)
     } finally {
       app.save()
+      app.working = false
+      app.afterLine?.()
     }
     const subtype = current.maxTurns ? 'error_max_turns' : error ? 'error_during_execution' : 'success' // as Claude Code names them
     current = null

package/src/settings.html

@@ -228,11 +228,15 @@
   .olist .test button { flex: none; }
   .olist .test.ok { color: var(--ok); }
   .olist .test.warn { color: var(--accent); }
-  dialog#ms { width: min(480px, calc(100vw - 32px)); border: 1px solid var(--line); border-radius: var(--radius); background: var(--panel); color: var(--text); padding: 22px 24px; }
-  dialog#ms::backdrop { background: rgba(0, 0, 0, .55); }
-  dialog#ms h2 { margin: 0 0 6px; font-family: var(--mono); font-size: 15px; overflow-wrap: anywhere; }
+  dialog { width: 70vw; max-width: none; max-height: calc(100vh - 32px); overflow: auto; border: 1px solid var(--line); border-radius: var(--radius); background: var(--panel); color: var(--text); padding: 22px 24px; }
+  dialog::backdrop { background: rgba(0, 0, 0, .55); }
+  dialog h2 { margin: 0 0 6px; font-family: var(--mono); font-size: 15px; overflow-wrap: anywhere; }
   dialog#ms .opt:last-of-type { border-bottom: 0; }
-  dialog#ms .actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 14px; }
+  #pr-list { list-style: none; margin: 12px 0 0; padding: 0; counter-reset: rank; }
+  #pr-list li { counter-increment: rank; padding: 9px 12px; margin-bottom: 6px; border: 1px solid var(--line); border-radius: 8px; background: var(--bg); cursor: grab; user-select: none; }
+  #pr-list li::before { content: counter(rank) ".  ⋮⋮  "; color: var(--muted); }
+  #pr-list li.dragging { opacity: .4; }
+  dialog .actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 14px; }
   .olist .test.failed { color: var(--err); }
   .olist .test.testing, .olist .test.waiting { color: var(--accent); }
   .olist .test button { padding: 0 7px; font-size: 11px; }
@@ -431,19 +435,6 @@
       </div>
       <div class="steps" id="steps"></div>
       <div class="stack">
-          <div class="card" id="p-form" hidden>
-            <h2 id="p-title">Add a provider</h2>
-            <p class="sub">Pick one to fill in its address, or type any OpenAI-compatible API below.</p>
-            <div class="presets" id="presets"></div>
-            <div class="row" style="margin-top:6px">
-              <div class="grow"><label class="f" for="p-name">Name</label><input type="text" id="p-name" placeholder="openrouter, groq, work…"></div>
-              <div class="grow" style="flex:2"><label class="f" for="p-url">Base URL</label><input type="text" id="p-url" placeholder="https://openrouter.ai/api/v1"></div>
-            </div>
-            <label class="f" for="p-key">API key <span class="muted" id="p-keynote" style="font-weight:normal"></span></label>
-            <input type="password" id="p-key" autocomplete="off" placeholder="paste it here (none for a server on this machine, like Ollama)">
-            <div class="hint">Kept in config.json on this machine. This page only shows its first and last characters.</div>
-            <div class="actions"><button class="primary" id="p-save">Add provider</button><button class="ghost" id="p-cancel">Cancel</button></div>
-          </div>
           <div class="work" id="p-work" hidden>
             <div class="card catalog">
               <div class="cat-top">
@@ -565,20 +556,8 @@
 
     <!-- MCP servers -->
     <section class="page" id="page-mcp">
-      <div class="head"><div><h1>MCP servers</h1><p class="lead">Programs that give the model more tools: a browser, a database, your issue tracker. Off: HeartCode doesn't start it or offer it to the model.</p></div></div>
+      <div class="head"><div><h1>MCP servers</h1><p class="lead">Programs that give the model more tools: a browser, a database, your issue tracker. Off: HeartCode doesn't start it or offer it to the model.</p></div><button class="primary" id="c-open">+ Add a server</button></div>
       <div class="stack">
-        <div class="card">
-          <h2>Add a server</h2>
-          <p class="sub">The command that starts it on this machine, or the URL of a remote one (a sign-in page opens if it needs one).</p>
-          <div class="row">
-            <div style="width:200px"><label class="f" for="c-name">Name</label><input type="text" id="c-name" placeholder="github"></div>
-            <div><label class="f">Kind</label><div class="seg" id="c-kind">
-              <label class="on"><input type="radio" name="c-kind" value="command" checked>Command</label><label><input type="radio" name="c-kind" value="url">URL</label>
-            </div></div>
-            <div class="grow" style="flex:3"><label class="f" for="c-what" id="c-what-label">Command</label><input type="text" id="c-what" placeholder="npx -y @modelcontextprotocol/server-github"></div>
-            <button class="primary" id="c-add">Add server</button>
-          </div>
-        </div>
         <div class="card" id="c-list"></div>
         <details class="card" id="c-raw"><summary style="cursor:pointer;font-weight:600">Edit mcp.json directly</summary><p class="sub" style="margin-top:10px">For what the form doesn't have: environment variables (<span class="mono">"env"</span>), headers, and so on.</p><div id="c-file"></div></details>
       </div>
@@ -617,6 +596,40 @@
     <div class="actions"><button id="ms-cancel" type="button">Cancel</button><button class="primary" id="ms-save" type="button">Save</button></div>
   </form>
 </dialog>
+<dialog id="p-form" aria-labelledby="p-title">
+  <h2 id="p-title">Add a provider</h2>
+  <p class="sub">Pick one to fill in its address, or type any OpenAI-compatible API below.</p>
+  <div class="presets" id="presets"></div>
+  <div class="row" style="margin-top:6px">
+    <div class="grow"><label class="f" for="p-name">Name</label><input type="text" id="p-name" placeholder="openrouter, groq, work…"></div>
+    <div class="grow" style="flex:2"><label class="f" for="p-url">Base URL</label><input type="text" id="p-url" placeholder="https://openrouter.ai/api/v1"></div>
+  </div>
+  <label class="f" for="p-key">API key <span class="muted" id="p-keynote" style="font-weight:normal"></span></label>
+  <input type="password" id="p-key" autocomplete="off" placeholder="paste it here (none for a server on this machine, like Ollama)">
+  <div class="hint">Kept in config.json on this machine. This page only shows its first and last characters.</div>
+  <div class="actions"><button id="p-cancel">Cancel</button><button class="primary" id="p-save">Add provider</button></div>
+</dialog>
+<dialog id="c-form" aria-labelledby="c-title">
+  <h2 id="c-title">Add a server</h2>
+  <p class="sub">The command that starts it on this machine, or the URL of a remote one (a sign-in page opens if it needs one).</p>
+  <div class="row">
+    <div style="width:200px"><label class="f" for="c-name">Name</label><input type="text" id="c-name" placeholder="github"></div>
+    <div><label class="f">Kind</label><div class="seg" id="c-kind">
+      <label class="on"><input type="radio" name="c-kind" value="command" checked>Command</label><label><input type="radio" name="c-kind" value="url">URL</label>
+    </div></div>
+    <div class="grow" style="flex:3"><label class="f" for="c-what" id="c-what-label">Command</label><input type="text" id="c-what" placeholder="npx -y @modelcontextprotocol/server-github"></div>
+  </div>
+  <div class="actions"><button id="c-cancel">Cancel</button><button class="primary" id="c-add">Add server</button></div>
+</dialog>
+<dialog id="k-form" aria-labelledby="k-title"></dialog>
+<dialog id="pr" aria-labelledby="pr-title">
+  <form>
+    <h2 id="pr-title">Provider ranking</h2>
+    <p class="sub">Drag the providers into order, best first. Your models are then sorted by it.</p>
+    <ol id="pr-list"></ol>
+    <div class="actions"><button id="pr-cancel" type="button">Cancel</button><button class="primary" id="pr-save" type="button">Save</button></div>
+  </form>
+</dialog>
 <div id="toast" role="status"></div>
 <div id="tip" role="tooltip"></div>
 <script>
@@ -766,7 +779,7 @@ const DRAFTS = { prompts: {}, skills: {}, files: {} }
 const SEL = { prompts: 'agent/system', skills: null, files: null }
 function masterDetail(kind, itemsEl, detailEl, groups, draw) {
   const all = groups.flatMap((g) => g.items)
-  if (!all.some((x) => x.id === SEL[kind]) && SEL[kind] !== '+new') SEL[kind] = all[0]?.id ?? null
+  if (!all.some((x) => x.id === SEL[kind])) SEL[kind] = all[0]?.id ?? null
   // the list: built when its items change; otherwise each item is updated in place (the chosen
   // one, a dot for unsaved changes, "yours"), so it stays where you scrolled it
   const inside = (x) => [h('div', { className: 't' }, DRAFTS[kind][x.id] !== undefined ? h('span', { className: 'dot', title: 'not saved' }) : null, x.title, x.badge ?? null), x.sub ? h('div', { className: 'd', textContent: x.sub }) : null]
@@ -787,7 +800,7 @@ function masterDetail(kind, itemsEl, detailEl, groups, draw) {
   }
   itemsEl.closest('.md').classList.toggle('solo', !all.length) // nothing to list: no list column
   itemsEl.closest('.md').classList.toggle('tabs', all.length > 0 && all.length <= 8) // a few: tabs on top
-  put(detailEl, draw(SEL[kind] === '+new' ? '+new' : all.find((x) => x.id === SEL[kind])))
+  put(detailEl, draw(all.find((x) => x.id === SEL[kind])))
   itemsEl.closest('.md').classList.add('fill')
   fillHeight()
 }
@@ -879,10 +892,8 @@ const useModel = (provider, model) => act('/api/model', { provider, model }, `He
 const saveOrder = (list, done, opts = {}) => act('/api/order', { list, ...opts }, done)
 
 let editing = null
-let formOpen = false
 function openForm(p = null) {
   editing = p
-  formOpen = true
   $('p-title').textContent = p ? `Edit ${p.name}` : 'Add a provider'
   $('p-name').value = p?.name ?? ''
   $('p-url').value = p?.baseUrl ?? ''
@@ -891,15 +902,11 @@ function openForm(p = null) {
   $('p-keynote').textContent = p?.key ? `(now ${p.key})` : ''
   $('p-save').textContent = p ? 'Save changes' : 'Add provider'
   drawPresets()
-  drawProviders(S)
-  $('p-form').scrollIntoView({ behavior: 'smooth', block: 'start' })
+  $('p-form').showModal()
   ;(p ? $('p-url') : $('p-name')).focus()
 }
-function closeForm() {
-  editing = null
-  formOpen = false
-  drawProviders(S)
-}
+const closeForm = () => $('p-form').close()
+$('p-form').onclose = () => (editing = null)
 $('p-open').onclick = () => openForm()
 $('p-cancel').onclick = closeForm
 $('p-save').onclick = async () => {
@@ -1183,17 +1190,12 @@ addEventListener('scroll', () => $('tip').classList.remove('show'), true)
 function drawProviders(s) {
   const order = s.order
   const none = !s.providers.length
-  // the steps: always on the page (nothing jumps when one is done), ticked off as you go; with
-  // no provider yet, the form is open (the only way in: no other button)
+  // the steps: always on the page (nothing jumps when one is done), ticked off as you go
   put($('steps'), [
     ['Add a provider', 'the service with your models', s.providers.length ? 'done' : 'now'],
     ['Choose a model', 'click one in the list', order.length ? 'done' : s.providers.length ? 'now' : ''],
     ['Start HeartCode', 'heart, in your project', order.length ? 'now' : ''],
   ].map(([t, d, cls], i) => h('div', { className: 'step ' + cls }, h('span', { className: 'num', textContent: cls === 'done' ? '✓' : i + 1 }), h('div', {}, h('b', { textContent: t }), d))))
-  const showForm = formOpen || none
-  $('p-form').hidden = !showForm
-  $('p-cancel').hidden = none // nothing to go back to
-  $('p-open').hidden = showForm
   $('p-work').hidden = none
   fillHeight()
 
@@ -1241,9 +1243,9 @@ function drawProviders(s) {
       h('label', { className: 'f', for: 'r-on', textContent: 'When the one in use fails, go on to the next' }),
       h('div', { className: 'row', style: 'gap:8px' },
         h('select', { id: 'r-on', style: 'flex:1', onchange: (e) => save(order, 'saved', { on: e.target.value }) },
-          [['failure', 'at its first failure'], ['retries', 'after some tries of the same model'], ['any', 'at any error']].map(([v, t]) => h('option', { value: v, textContent: t, selected: s.rotation.on === v }))),
+          [['failure', 'at its first failure'], ['retries', 'after some tries of the same model (rate limits, outages)']].map(([v, t]) => h('option', { value: v, textContent: t, selected: s.rotation.on === v }))),
         s.rotation.on === 'retries' ? h('input', { type: 'number', 'aria-label': 'tries', title: 'tries of the same model first', style: 'width:76px', min: 1, max: 20, value: s.rotation.retries, onchange: (e) => save(order, 'saved', { retries: Number(e.target.value) }) }) : null),
-      h('div', { className: 'hint', textContent: { failure: 'A rate limit, server error, timeout or lost connection moves on at once, and so does a model it can\'t use (a wrong key, no access, "model not found"). Other errors, like a bad request, stop.', retries: 'The same model is tried again (with a short wait) that many times first.', any: 'Also errors like "model not found" or a bad request move on.' }[s.rotation.on] }),
+      h('div', { className: 'hint', textContent: { failure: 'Any error moves on at once, to another provider\'s model first. It stops only when every model fails.', retries: 'A rate limit or outage: the same model is tried again (with a short wait) that many times first. Any other error moves on at once.' }[s.rotation.on] ?? 'Any error moves on at once, to another provider\'s model first.' }),
       h('label', { className: 'f', for: 'r-next', textContent: 'A new message starts with' }),
       h('select', { id: 'r-next', onchange: (e) => save(order, 'saved', { next: e.target.value }) },
         [['first', '#1 again'], ['stay', 'the model that answered last']].map(([v, t]) => h('option', { value: v, textContent: t, selected: s.rotation.next === v })))) : null)
@@ -1479,7 +1481,7 @@ const can = (t) => ({ tools: t.tested ? t.tested.mode === 'tools' : t.known?.too
 // how: text (A to Z first), cheap (lowest first), else most first
 const COLS = {
   model: { label: 'Model', how: 'text', get: (t) => t.model },
-  provider: { label: 'Provider', how: 'text', get: (t) => t.provider },
+  provider: { label: 'Provider', how: 'rank', get: (t) => RANKED.get(t.provider) }, // by your ranking of the providers
   context: { label: 'Context', get: (t) => t.tested?.context ?? t.known?.context ?? 0 },
   abilities: { label: 'Abilities', get: (t) => Object.values(can(t)).filter(Boolean).length },
   tools: { label: 'Tools', get: (t) => can(t).tools },
@@ -1496,6 +1498,44 @@ let SORT = (() => {
     return []
   }
 })()
+// your ranking of the providers, best first, kept in this browser; a provider not ranked yet comes after, A to Z
+let RANK = (() => {
+  try {
+    return JSON.parse(localStorage.getItem('heart.rank') ?? '[]').filter((x) => typeof x === 'string')
+  } catch {
+    return []
+  }
+})()
+const ranked = () => {
+  const names = [...new Set(S.order.map((t) => t.provider))]
+  return [...RANK.filter((n) => names.includes(n)), ...names.filter((n) => !RANK.includes(n)).sort(byName)]
+}
+// the ranking dialog: drag a provider to its place, then Save
+function openRanking() {
+  const list = $('pr-list')
+  let held = null
+  put(list, ranked().map((name) => h('li', { draggable: true, textContent: name })))
+  list.ondragstart = (e) => (held = e.target).classList.add('dragging')
+  list.ondragend = () => held?.classList.remove('dragging')
+  list.ondragover = (e) => {
+    e.preventDefault()
+    const over = e.target.closest('li')
+    if (!held || !over || over === held) return
+    const r = over.getBoundingClientRect()
+    list.insertBefore(held, e.clientY > r.top + r.height / 2 ? over.nextSibling : over)
+  }
+  $('pr').showModal()
+}
+$('pr-cancel').onclick = () => $('pr').close()
+$('pr-save').onclick = () => {
+  const list = [...$('pr-list').children].map((li) => li.textContent)
+  RANK = [...list, ...RANK.filter((n) => !list.includes(n))] // providers not in your list now keep their place for later
+  try {
+    localStorage.setItem('heart.rank', JSON.stringify(RANK))
+  } catch {}
+  $('pr').close()
+  setSort(SORT.some((x) => x.key === 'provider') ? SORT : [{ key: 'provider', dir: 'up' }, ...SORT]) // sorted by it now
+}
 const firstDir = (key) => (COLS[key].how ? 'up' : 'down') // up: A to Z, low to high
 function setSort(next) {
   SORT = next
@@ -1511,7 +1551,9 @@ function clickSort(key) {
   if (at.dir === firstDir(key)) return setSort(SORT.map((x) => (x === at ? { key, dir: at.dir === 'up' ? 'down' : 'up' } : x)))
   setSort(SORT.filter((x) => x !== at))
 }
+let RANKED = new Map() // provider → its place in the ranking, for one sort
 function sorted(order) {
+  RANKED = new Map(ranked().map((n, i) => [n, i]))
   const cmp = (a, b, { key, dir }) => {
     let x = COLS[key].get(a)
     let y = COLS[key].get(b)
@@ -1523,7 +1565,7 @@ function sorted(order) {
   }
   return order.map((t, i) => ({ t, i })).sort((a, b) => SORT.reduce((r, s) => r || cmp(a.t, b.t, s), 0) || a.i - b.i).map((x) => x.t)
 }
-const dirText = (key, dir) => (key === 'works' ? (dir === 'down' ? 'working first' : 'not working first') : COLS[key].how === 'text' ? (dir === 'up' ? 'A→Z' : 'Z→A') : COLS[key].how === 'cheap' ? (dir === 'up' ? 'cheapest first' : 'priciest first') : dir === 'down' ? 'most first' : 'least first')
+const dirText = (key, dir) => (key === 'provider' ? (dir === 'up' ? 'your ranking' : 'your ranking, reversed') : key === 'works' ? (dir === 'down' ? 'working first' : 'not working first') : COLS[key].how === 'text' ? (dir === 'up' ? 'A→Z' : 'Z→A') : COLS[key].how === 'cheap' ? (dir === 'up' ? 'cheapest first' : 'priciest first') : dir === 'down' ? 'most first' : 'least first')
 // The models ticked on the Your models page ("provider/model"), to remove several at once; the last
 // one ticked, so a Shift+click ticks the ones between
 const PICKED = new Set()
@@ -1594,6 +1636,7 @@ function drawMine(s) {
       PICKED.size ? h('button', { className: 'small danger', textContent: `Remove ${PICKED.size} selected`, onclick: removePicked }) : null,
       PICKED.size ? h('button', { className: 'small', textContent: `Test ${PICKED.size} selected`, disabled: testingAll, onclick: () => tryAll(order.filter((t) => PICKED.has(keyOf(t)))) }) : null,
       PICKED.size ? h('button', { className: 'small', textContent: 'Clear selection', onclick: () => (PICKED.clear(), drawMine(S)) }) : null,
+      order.some((t) => t.provider !== order[0].provider) ? h('button', { className: 'small', textContent: 'Provider ranking', title: 'drag your providers into order; the Provider column sorts by it', onclick: openRanking }) : null,
       SORT.length ? h('button', { className: 'small', textContent: 'Clear sort', onclick: () => setSort([]) }) : null,
       SORT.length ? h('button', { className: 'small primary', textContent: same ? 'This is your order' : 'Use this order', disabled: same, onclick: () => keep(view) }) : null,
       order.length ? h('button', { className: 'small', textContent: 'Refresh from models.dev', title: 'ask models.dev again what each model can do: context, tools, thinking, images, price', onclick: () => lookUp() }) : null,
@@ -1845,8 +1888,10 @@ for (const r of document.querySelectorAll('input[name="c-kind"]')) r.onchange =
 }
 $('c-add').onclick = async () => {
   const r = await act('/api/mcp/add', { name: $('c-name').value, [mcpKind()]: $('c-what').value }, `added ${$('c-name').value.trim()}: it starts from the next message`)
-  if (r) $('c-name').value = $('c-what').value = ''
+  if (r) ($('c-name').value = $('c-what').value = ''), $('c-form').close()
 }
+$('c-open').onclick = () => ($('c-form').showModal(), $('c-name').focus())
+$('c-cancel').onclick = () => $('c-form').close()
 function drawMcp(s) {
   put($('c-list'), h('h2', { textContent: 'Servers' }), h('p', { className: 'sub', textContent: 'Built in, and yours. Switch one off to keep it without using it.' }),
     s.mcp.length ? s.mcp.map((m) => h('div', { className: 'opt' },
@@ -1873,7 +1918,27 @@ function parseSkill(text) {
 }
 const skillText = (k) => `---\n${k.description.trim() ? `description: ${k.description.trim().replace(/\n/g, ' ')}\n` : ''}use: ${k.use}\n${k.extra.map((l) => l + '\n').join('')}---\n\n${k.body.trim()}\n`
 const NEW = { name: '', description: '', use: 'both', extra: [], body: '' }
-$('k-new').onclick = () => ((SEL.skills = '+new'), S && drawSkills(S))
+// a new skill: the form in a dialog (what you typed is kept if you close it)
+function newSkill() {
+  const f = skillForm('+new', NEW, { isNew: true })
+  const first = !S.skills.length
+  put($('k-form'), h('h2', { id: 'k-title', textContent: first ? 'Make your first skill' : 'New skill' }),
+    first ? h('p', { className: 'sub', textContent: 'A skill is a prompt you use again and again, like "review this" or "write the release notes". Skills from Claude Code and others: /import in HeartCode.' }) : null,
+    f.el,
+    h('div', { className: 'actions' },
+      h('button', { textContent: 'Cancel', onclick: () => $('k-form').close() }),
+      h('button', { className: 'primary', textContent: 'Create skill', onclick: async () => {
+        const slug = f.d.name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '')
+        if (!f.d.body.trim()) return toast('Write the prompt first', true)
+        const was = SEL.skills
+        SEL.skills = slug // the new one, chosen in the list once it's there
+        if (await saveItem('skills', '+new', '/api/skill', { name: f.d.name, text: skillText(f.d) }, `created /${slug}`)) $('k-form').close()
+        else SEL.skills = was
+      } })))
+  $('k-form').showModal()
+  $('k-form').querySelector('input')?.focus()
+}
+$('k-new').onclick = newSkill
 function skillForm(id, start, { isNew, readOnly }) {
   const d = DRAFTS.skills[id] ?? { ...start, extra: [...start.extra] } // your unsaved changes, else as saved
   const touch = () => (DRAFTS.skills[id] = d) // a change: kept (and dotted in the list) until it's saved
@@ -1891,27 +1956,11 @@ function skillForm(id, start, { isNew, readOnly }) {
   ] }
 }
 function drawSkills(s) {
-  if (!s.skills.length) SEL.skills = '+new' // none yet: the form is the page (one way in, no empty card)
-  $('k-new').hidden = SEL.skills === '+new'
   const mine = s.skills.filter((k) => k.mine)
   const theirs = s.skills.filter((k) => !k.mine)
   const item = (k) => ({ id: k.name, title: '/' + k.name, sub: k.description, k })
   masterDetail('skills', $('k-items'), $('k-detail'), [{ title: mine.length && theirs.length ? 'Yours' : '', items: mine.map(item) }, { title: 'From projects', items: theirs.map(item) }], (x) => {
-    if (x === '+new') {
-      const f = skillForm('+new', NEW, { isNew: true })
-      const first = !s.skills.length
-      return h('div', { className: 'card' }, h('h2', { textContent: first ? 'Make your first skill' : 'New skill' }),
-        first ? h('p', { className: 'sub', textContent: 'A skill is a prompt you use again and again, like "review this" or "write the release notes". Skills from Claude Code and others: /import in HeartCode.' }) : null,
-        f.el,
-        h('div', { className: 'actions' },
-          h('button', { className: 'primary', textContent: 'Create skill', onclick: async () => {
-            const slug = f.d.name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '')
-            if (!f.d.body.trim()) return toast('Write the prompt first', true)
-            SEL.skills = slug // the new one, chosen in the list once it's there
-            if (!(await saveItem('skills', '+new', '/api/skill', { name: f.d.name, text: skillText(f.d) }, `created /${slug}`))) SEL.skills = '+new'
-          } }),
-          first ? null : h('button', { className: 'ghost', textContent: 'Cancel', onclick: () => (saved('skills', '+new'), (SEL.skills = null), drawSkills(S)) })))
-    }
+    if (!x) return h('div', { className: 'card' }, h('h2', { textContent: 'No skills yet' }), h('p', { className: 'sub', textContent: 'A skill is a prompt you use again and again, like "review this" or "write the release notes". Make one with + New skill, or bring them from Claude Code and others with /import in HeartCode.' }))
     const k = x.k
     const f = skillForm(k.name, parseSkill(k.text), { readOnly: !k.mine })
     return h('div', { className: 'card' },