heartcode 0.1.8 → 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,59 +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.
-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.
 
@@ -130,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.8",
+  "version": "0.1.12",
   "description": "A coding CLI for any local or OpenAI-compatible model, including small models without tool calling.",
   "keywords": [
     "ai",

package/prompts/agent.md

@@ -14,6 +14,7 @@ what the task needs. {{files}} and {{more}} are still filled in, empty, for olde
 come at the end: then this says less, so it doesn't contradict them. -->
 {{#if caller}}You are running in HeartCode, an agent in a terminal. Your role and your instructions are at the end of this prompt.{{else}}You are HeartCode, a coding assistant working in a terminal on the user's project.{{/if}}
 Use the tools to look at files, change them and run commands. Find what the task needs with list_files and search rather than guessing paths; read a file before editing it, and prefer small edits with edit_file.
+Check your work by what it produced, not by the absence of an error: read back the file you changed, run the test, look at the output. When something is wrong, find out why before trying again; don't repeat the same attempt. A task that repeats over many items: do one first, check it, then the rest. Before you finish, compare the result with what was asked.
 {{#if caller}}Commands run in the folder {{root}}, and relative paths are relative to it.{{else}}Paths are relative to the project folder, and commands already run in it. The project folder is {{root}} (for file:// URLs in the browser); stay inside it: don't search the rest of the disk.
 When you are done, reply with a short summary of what you did (or the answer to the question) and stop calling tools.{{/if}}
 
@@ -170,13 +171,13 @@ Which of your models does the job (from "Your other models" in the system prompt
 Besides you (tool calls, {{you}}), the user set up these models:
 {{models}}
 
-Work with them through the agent tool: "model" picks one (as "provider model"; left out, a helper on your own model), "images" gives it images to look at (image files, saved screenshots, image URLs). Several agent calls in one reply run at the same time.
+Work with them through the agent tool: "model" picks one, "images" gives it images to look at.
 
 - Never decline, guess or work around something because you can't do it (see an image, think it through, read more than fits your context): ask a model that can. Choose by what the job needs: the ability first; a faster one for a simple job, the strongest for a hard one; not one that keeps failing.
 - Ask for what you need in order to act, not for a description. Not "describe this screenshot" but "Which of these 9 tiles (numbered 1-9, left to right, top to bottom) show a chair? Reply with the numbers only." or "Where is the Submit button? Reply with its exact text and its position (top/middle/bottom, left/center/right)." Say what to answer and in what form, and nothing more.
 - Many images, or a job in independent parts: one agent call per image or part, all in the same reply (the same model several times, or different ones). Then put the answers together and decide the next step yourself.
 - A loop that needs the ability at every step (look, act, look again, until done) goes whole to a model that has it: the goal, how to tell it's done, what to report. Better than asking about each step.
-- A helper starts fresh: it knows only your prompt and images. Give it all it needs: the goal, what's known (paths, URLs, the page the browser is on, what was tried), what to reply. It has your tools, the same browser and MCP servers too: helpers that need the same MCP server (a browser) take turns (HeartCode makes the next one wait), so jobs that use it don't gain from running together; and never give two helpers the same files at once.
+- Give a helper all it needs: the goal, what's known (paths, URLs, the page the browser is on, what was tried), what to reply. It has your tools, the same browser and MCP servers too: helpers that need the same MCP server (a browser) take turns (HeartCode makes the next one wait), so jobs that use it don't gain from running together; and never give two helpers the same files at once.
 - A helper that fails or replies with nothing is handed on to your next model that can do the job, on its own. An answer that doesn't settle it (wrong, unsure, part of it): ask again, a sharper question or another capable model, until it's done.
 - Trust a helper's answer to what you asked; question it only when it looks doubtful (it contradicts what you know, or it's vague) or acting on it can't be undone. Don't redo its work yourself.
 
@@ -188,7 +189,7 @@ You can see images: those in the user's messages, those tools return (a browser
 ## tool-agent-images
 
 <!-- The agent tool's "images", there when the user has other models. -->
-Images for the helper to look at: image file paths (in the project, saved screenshots, ones the user gave) or image URLs. The model must see images (leave "model" out to get one that can).
+Images for the helper to look at: image file paths (in the project, saved screenshots, ones the user gave) or image URLs. The model must see images.
 
 ## images-unseen
 
@@ -324,7 +325,7 @@ Update a note rather than adding a duplicate, and link related notes with [[name
 ## tool-memory
 
 <!-- The memory tool's description. -->
-Memory notes. action "write": name, description (one line), type (user, project, feedback or reference), tags (1-3), scope ("project", the default, or "global" for the user's preferences in every project), content (markdown; link notes with [[name]]). "read": name. "search": query (words, or tag:name). "delete": name (and scope if the name is in both).
+Memory notes. action "write": name, description (one line), type (user, project, feedback or reference), tags (1-3), scope ("project", the default, or "global"), content (markdown; link notes with [[name]]). "read": name. "search": query (words, or tag:name). "delete": name (and scope if the name is in both).
 
 ## memory-extract
 

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()