heartcode 0.1.9 → 0.1.13

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, takeIn, whatOf, 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'
@@ -26,6 +26,7 @@ import { createWorktree, worktreeState, removeWorktree } from '../src/worktree.j
 import { runAcp } from '../src/acp.js'
 import { Tabs } from '../src/tabs.js'
 import { startSettings } from '../src/settings.js'
+import { loadHooks } from '../src/hooks.js'
 import { RESETS, reset, resetPaths, resetCode } from '../src/reset.js'
 
 const LOCAL_SERVERS = ['http://localhost:11434/v1', 'http://localhost:1234/v1', 'http://localhost:8080/v1']
@@ -37,8 +38,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,14 +48,17 @@ ${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
       --hide-thinking    collapse the model's thinking to one line
   -C, --cwd <dir>        project folder (default: current folder)
-      --temp             a throwaway settings folder for this run (your providers, model tests
-                         and prices copied in; deleted after); ~/.heart isn't touched
+      --temp             a throwaway settings folder (your providers, model tests and prices
+                         copied in), shared by the --temp runs going on at once and deleted
+                         after the last; ~/.heart isn't touched
       --context <n>      context window size in tokens
       --force            re-run the probe
       --save             keep the given -u/-m/--api-key/... in ${CONFIG_FILE}
@@ -61,7 +66,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
@@ -176,12 +181,15 @@ class App {
     return mcp
   }
 
-  // After a skill or MCP server was saved or deleted (by the director or /import).
-  reload(kind) {
+  // After a skill or MCP server was saved or deleted (the settings page, the director, /import):
+  // from the next tool call. The old servers are stopped once the message in progress is done
+  // (busy), so a call to one of them finishes.
+  reload(kind, busy = false) {
     if (kind === 'skill') this.skills = loadSkills(this.root)
     if (kind === 'mcp') {
-      this.mcp.dispose()
+      const old = this.mcp
       this.mcp = this.newMcp()
+      busy ? this.later.push(() => old.dispose()) : old.dispose()
     }
     if (this.s) Object.assign(this.s, { skills: this.skills, mcp: this.mcp })
   }
@@ -229,13 +237,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 +320,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 +645,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 +743,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 +763,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,29 +857,32 @@ 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 of the settings (the settings page, another HeartCode on the same folder, a hand), brought
+// into every open tab and run (also -p and ACP) right away: the running task's next request has it
+// (the model list's #1, the prompts, hooks, skills, MCP servers…).
 function applySettings(apps, cfg, what) {
   const before = themeCodes()
   if (what === 'theme' || what === 'setting:theme') setTheme(cfg.theme)
-  if (what === 'prompts') reloadPrompts() // from each tab's next message
+  if (what === 'prompts') reloadPrompts()
   if (['setting:log', 'setting:logRequests', 'setting:logDetail'].includes(what)) useRequestLog(cfg) // the run's log and the requests', on or off now
   if (what === 'setting:logDays') pruneLogs(logDays(cfg))
   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 +890,13 @@ 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())
-    if (what === 'mcp' || what === 'skill') now(() => app.reload(what))
+    // 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') app.reload(what, busy)
+    if (what === 'prompts' && app.s) app.s.refreshSystem = true // the system prompt, again before the next request
+    if (what === 'hooks' && app.s && app.s.hooks !== false) app.s.hooks = loadHooks(app.root)
     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()
   }
@@ -928,10 +904,10 @@ function applySettings(apps, cfg, what) {
 }
 
 // Changes saved by another HeartCode, or \`heart settings\` in another terminal, while this one runs:
-// taken in as the page's own are (applySettings). config.json is compared key by key with what it
-// was (so a model given for this run with -m stays unless the list's #1 changes); the other files
-// by their size and time, and only when this run didn't just apply them itself.
-const WATCHED = { 'mcp.json': 'mcp', 'keybindings.json': 'keys', 'theme.json': 'theme', models: 'profile', prompts: 'prompts', skills: 'skill' }
+// taken in as the page's own are (applySettings). config.json: the keys others changed (takeIn; a
+// model given for this run with -m stays unless the list's #1 changes); the other files by their
+// size and time, and only when this run didn't just apply them itself.
+const WATCHED = { 'mcp.json': 'mcp', 'hooks.json': 'hooks', 'keybindings.json': 'keys', 'theme.json': 'theme', models: 'profile', prompts: 'prompts', 'HEARTCODE.md': 'prompts', skills: 'skill' }
 const seenStamp = {}
 const stampOf = (p) => {
   try {
@@ -946,21 +922,9 @@ function settingsSeen(what) {
   for (const [name, w] of Object.entries(WATCHED)) if (w === what || (what === 'setting:theme' && w === 'theme')) seenStamp[name] = stampOf(path.join(HOME, name))
 }
 function watchSettings(apps, cfg) {
-  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
-  let last = readJson(CONFIG_FILE, {})
   for (const name of Object.keys(WATCHED)) seenStamp[name] = stampOf(path.join(HOME, name))
   const configChanged = () => {
-    const now = readJson(CONFIG_FILE, null)
-    if (!now) return
-    const keys = [...new Set([...Object.keys(now), ...Object.keys(last)])].filter((k) => !same(now[k], last[k]))
-    last = now
-    const whats = new Set()
-    for (const k of keys) {
-      const value = k === 'providers' ? { ...now.providers, ...(cfg.adhoc && { [cfg.adhoc]: cfg.providers[cfg.adhoc] }) } : now[k]
-      if (same(value, cfg[k])) continue
-      value === undefined ? delete cfg[k] : (cfg[k] = value)
-      whats.add(['provider', 'model', 'providers'].includes(k) ? 'model' : k === 'rotation' ? 'setting:rotation' : `setting:${k}`)
-    }
+    const whats = new Set(takeIn(cfg).map(whatOf))
     for (const what of whats) applySettings(apps(), cfg, what)
     if (whats.size) log('settings', `taken in from config.json: ${[...whats].join(', ')}`)
   }
@@ -1436,6 +1400,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 +1460,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 +1493,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 +1579,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 +1593,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.13",
   "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,16 @@ 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`)
+    // the prompts or HEARTCODE.md changed meanwhile (applySettings): the system prompt again, now
+    if (s.refreshSystem && (s.messages[0]?.role === 'system' || strat.mergeSystem)) s.messages[0] = { ...s.messages[0], content: SYSTEM(s) }
+    s.refreshSystem = false
+    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)