heartcode 0.1.15 → 0.1.25

package/bin/heartcode.js

@@ -7,7 +7,7 @@ import { probe, loadProfile, strategy, describe, profilePath, profileFrom } from
 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'
+import { UI, c, PERMISSIONS, duration, copyText, rank, setTheme, themeCodes, renderDiff, diffLines, DEFAULT_KEYS, loadKeys } from '../src/ui.js'
 import { listFiles, runCommand, clip } from '../src/tools.js'
 import { log, LOG_FILE, LOG_DIR, requestLog, useRequestLog, useLogs, pruneLogs, logDays } from '../src/log.js'
 import { prompt, usePromptsFrom, reloadPrompts } from '../src/prompts.js'
@@ -97,11 +97,11 @@ ${c.bold('in a session')}  attach an image with @path/to/shot.png · /help for c
 // [name, description, takes an argument], by section. /help and the "/" menu are built from it.
 const SECTIONS = [
   ['providers and models', [
-    ['/select_model', 'switch to another of your models (the list, and every provider\'s models: /settings)', true],
+    ['/select_model', 'pick the model(s) for this session: one pins it, several rotate among them, auto = your whole list', true],
   ]],
   ['settings', [
     ['/toggle_thinking', "show or collapse the model's thinking"],
-    ['/voice', 'say your message (or press Ctrl+R in the input): it goes in the input box'],
+    ['/voice', 'say your message: Space to talk, Enter to finish; it shows in the input box as you speak'],
   ]],
   ['session', [
     ['/resume', 'continue an earlier session in this folder'],
@@ -126,6 +126,7 @@ const SECTIONS = [
     ['/settings', 'change providers, models, settings, MCP servers, hooks, keys and skills in your browser'],
     ['/help', 'this list'],
     ['/tab', 'a new tab (Ctrl+T): another conversation beside this one · /tab worktree [name]: in its own git worktree · /tab 2: go to tab 2 (Ctrl+N/P) · Ctrl+Q closes one', true],
+    ['/close_tab', 'close this tab (Ctrl+Q); asks first'],
     ['/exit', 'quit HeartCode (Ctrl+Q closes just this tab)'],
   ]],
 ]
@@ -139,6 +140,7 @@ const HOWTO = `${c.yellow('No model set up yet.')} Add a provider and choose its
 
 ${c.dim('Ollama, LM Studio or llama.cpp running on this machine is found on its own.')}`
 const NO_MODELS = `${c.yellow('No model chosen yet.')} Choose one on ${c.cyan('/settings')}: a provider's models, click one.`
+const ALL_OFF = `${c.yellow('The providers of all your models are switched off.')} Switch one on on ${c.cyan('/settings')}, or add a model of one that's on.`
 
 // Choices for commands that take one (also offered in the "/" menu).
 const ARGS = {
@@ -166,6 +168,23 @@ class App {
     this.director = new Director(this) // the manage tool: skills, MCP servers and settings by asking
     this.later = [] // setting changes that wait until the current message is done
     this.failures = {} // "provider model" → failed requests this session (engine: onFail)
+    this.loadProjectModels() // the model(s) you last chose for this folder (.heartcode/models.json)
+  }
+
+  // Per folder: the model set you picked with /select_model, remembered in .heartcode/models.json and
+  // restored when you open this folder again. Absent/empty means auto (your whole list). A -m model
+  // from the command line (cfg.session already set) wins and isn't overwritten.
+  loadProjectModels() {
+    if (this.cfg.session) return
+    const saved = readJson(path.join(this.root, '.heartcode', 'models.json'), null)
+    const valid = (saved?.session ?? []).filter((t) => t?.provider && t?.model && this.cfg.providers[t.provider])
+    if (valid.length) this.cfg.session = valid
+  }
+
+  saveProjectModels() {
+    const file = path.join(this.root, '.heartcode', 'models.json')
+    if (this.cfg.session?.length) writeJson(file, { session: this.cfg.session.map((t) => ({ provider: t.provider, model: t.model })) })
+    else fs.rmSync(file, { force: true }) // auto: forget the folder's choice
   }
 
   newMcp() {
@@ -206,7 +225,7 @@ class App {
       `effort: ${cfg.effort ?? 'default'}`,
       `auto_compact: ${cfg.autoCompact === false ? 'off' : 'on'}`,
       `director: ${cfg.director === false ? 'off' : 'on'}`,
-      `model: ${cfg.provider ?? '(none)'} ${cfg.model ?? ''}`,
+      `model: ${this.inUse() ? `${this.inUse().provider} ${this.inUse().model}` : '(none)'}`,
       `providers: ${Object.keys(cfg.providers).join(', ') || '(none)'}`,
     ].join('\n')
   }
@@ -287,17 +306,38 @@ class App {
       if (this.s?.client === client) this.s.profile = profile // /model_info, the settings page
     }
     apply()
+    // the profile file as this run last read or wrote it: changed since (the settings page, another
+    // HeartCode, a helper on the same model), it's read again before the next request
+    let stamp = stampOf(profilePath(client))
     client.onUse = (t) => {
       profile = loadProfile(client) || profileFrom(client, limitsOf(t.provider, client.baseUrl, t.model))
+      stamp = stampOf(profilePath(client))
       apply()
       log('rotate', `${t.provider} · ${t.model}: ${strat.actions}${strat.vision ? ', images' : ''}, ~${strat.context} tokens`)
     }
-    // Saved with what another connection to the same model (a helper on it) learned meanwhile: the
-    // provider's refusals of both are kept (each writes its whole profile).
+    // The settings as they are now, whatever did or didn't tell this run they changed: before every
+    // request (this model's, a helper's, guided mode's, a summary's) and before a tool's result is cut
+    // to the window (a command can run for minutes). Nothing goes on with an old copy.
+    client.refresh = () => {
+      syncSettings()
+      if (stampOf(profilePath(client)) !== stamp) client.onUse({ provider: client.provider, model: client.model })
+    }
+    // What this run learned about the model, onto its file as it is now: the rest (what you set up for
+    // it on the settings page, a measured window, models.dev's word) stays the file's. The provider's
+    // refusals that another connection to it (a helper) learned meanwhile are kept too.
     const save = () => {
-      const disk = readJson(profilePath(client), null)
-      if (disk?.model === profile.model) profile.quirks = { ...disk.quirks, ...profile.quirks }
-      writeJson(profilePath(client), profile)
+      const file = profilePath(client)
+      const disk = readJson(file, null)
+      if (disk?.model === profile.model) {
+        const out = { ...disk, quirks: { ...disk.quirks, ...profile.quirks } }
+        for (const k of LEARNED) k in profile ? (out[k] = profile[k]) : delete out[k]
+        if (disk.source === 'assumed' && profile.source !== 'assumed') out.source = profile.source // models.dev knows it now
+        profile = out
+      }
+      writeJson(file, profile)
+      stamp = stampOf(file)
+      settingsSeen('profile') // its own write: not a change to take in
+      apply()
     }
     // What the window is, learned while working (context.js); kept in the profile for next time.
     const learned = () => {
@@ -386,7 +426,8 @@ class App {
       'Go back to before which message?',
       turns.map(({ t, i }) => {
         const n = Object.keys(chat.turns.slice(i).reduce((all, x) => Object.assign(all, x.files), {})).length
-        return { label: t.task.split('\n')[0].slice(0, 70), desc: `${ago(t.at)}${n ? ` · ${n} file${n > 1 ? 's' : ''} changed since` : ''}`, i }
+        const num = `${i + 1}.`.padStart(String(chat.turns.length).length + 1) // its number in the conversation, newest first
+        return { label: `${num} ${t.task.split('\n')[0].slice(0, 70)}`, desc: `${ago(t.at)}${n ? ` · ${n} file${n > 1 ? 's' : ''} changed since` : ''}`, i }
       }),
     )
     if (!pickTurn) return
@@ -561,33 +602,50 @@ class App {
     const sep = c.ghost(' │ ')
     if (!cfg.providers[cfg.provider] || !cfg.model) return c.dim('no model · /settings to choose one')
     const rot = this.s?.client.rotation
-    const now = rot?.list[rot.at] ?? { provider: cfg.provider, model: cfg.model } // the model list: the one in use
-    const parts = [`${c.brand('●')} ${c.muted(now.provider)} ${c.ghost('·')} ${c.info(now.model)}${rot ? c.faint(` ↻ ${rot.at + 1}/${rot.list.length}`) : ''}`]
-    const key = `${cfg.provider}/${cfg.model}`
-    if (this.profileKey !== key) [this.profileKey, this.profile] = [key, this.s?.profile ?? loadProfile(this.client(cfg.provider, cfg.model))]
+    const now = this.inUse() // the model list's one in use; never one of a provider that's off
+    if (!now) return c.dim('the providers of all your models are off · /settings to switch one on')
+    // provider (providers on) · the model. Auto (rotating your list): "auto (current model) (list
+    // size)". A model you picked (pinned, no rotation): just its name.
+    const on = Object.values(cfg.providers).filter((p) => !p.off).length
+    // one model (pinned): just its name. Several chosen for this session: the one in use + "N chosen".
+    // Your whole list (auto): "auto (in use) (N)". ↻ shows the rotation position while rotating.
+    const count = this.sessionModels().length
+    // the model answering now; a "↻" before it, in yellow, when it's a fallback (rotated to after one
+    // failed) — so you can see at a glance it isn't the first/preferred one
+    const rotated = rot && rot.at > 0
+    const name = rotated ? `${c.yellow('↻ ' + now.model)}` : c.info(now.model)
+    const model =
+      count === 1
+        ? name
+        : cfg.session
+          ? `${name} ${c.faint(`(${count} chosen)`)}`
+          : `${c.muted('auto')} ${c.faint('(')}${name}${c.faint(')')} ${c.faint(`(${count})`)}`
+    // two lines so nothing is crammed: the model and what it can do, then the run's stats and controls
+    const first = [`${c.brand('●')} ${c.muted(now.provider)} ${c.faint(`(${on})`)} ${c.ghost('·')} ${model}`]
+    const second = []
+    const key = `${now.provider}/${now.model}`
+    if (this.profileKey !== key) [this.profileKey, this.profile] = [key, this.s?.profile ?? loadProfile(this.client(now.provider, now.model))]
     const profile = this.s?.profile ?? this.profile
     if (profile) {
       const strat = this.s?.strat ?? strategy(profile, cfg)
-      parts.push(c.muted(strat.actions === 'tools' ? 'tools' : 'guided'))
-      if (strat.thinking) parts.push(c.think(`thinking${cfg.effort ? ` · ${cfg.effort}` : ''}`) + (ui.showThinking ? '' : c.faint(' (collapsed)')))
-      if (strat.vision) parts.push(c.muted('images'))
+      first.push(c.muted(strat.actions === 'tools' ? 'tools' : 'guided'))
+      if (strat.thinking) first.push(c.think(`thinking${cfg.effort ? ` · ${cfg.effort}` : ''}`) + (ui.showThinking ? '' : c.faint(' (collapsed)')))
+      if (strat.vision) first.push(c.muted('images'))
       const used = this.s?.client.lastTokens ?? 0
       const pct = Math.round((used / strat.context) * 100)
       const paint = pct >= 80 ? c.red : pct >= 50 ? c.yellow : c.green
       const guess = strat.contextSure ? '' : '~' // not said by the server: assumed, and growing as bigger requests work
-      parts.push(`${c.faint('ctx')} ${paint(`${kTokens(used)}/${guess}${kTokens(strat.context)}`)} ${c.faint(`${pct}%`)}`)
+      second.push(`${c.faint('ctx')} ${paint(`${kTokens(used)}/${guess}${kTokens(strat.context)}`)} ${c.faint(`${pct}%`)}`)
       const tps = this.s?.client.tps
-      if (tps) parts.push(`${c.muted(String(tps))} ${c.faint('tok/s')}`)
-      if (this.chat.usage?.priced) parts.push(c.muted(money(this.chat.usage.cost)))
+      if (tps) second.push(`${c.muted(String(tps))} ${c.faint('tok/s')}`)
+      if (this.chat.usage?.priced) second.push(c.muted(money(this.chat.usage.cost)))
     } else {
-      parts.push(c.dim('not probed yet'))
+      first.push(c.dim('not probed yet'))
     }
-    if (cfg.autoCompact === false) parts.push(c.faint('auto-compact off'))
-    if (this.worktree) parts.push(c.info(`⎇ ${this.worktree.branch}`))
-
-    const perm = { all: c.green('⏵⏵ all allowed'), commands: c.yellow('ask before commands'), ask: c.yellow('ask before changes'), plan: c.info('⏸ plan mode') }[ui.permission]
-    parts.push(perm) // Shift+Tab changes it (see the header)
-    return parts.join(sep)
+    if (cfg.autoCompact === false) second.push(c.faint('auto-compact off'))
+    if (this.worktree) second.push(c.info(`⎇ ${this.worktree.branch}`))
+    second.push({ all: c.green('⏵⏵ all allowed'), commands: c.yellow('ask before commands'), ask: c.yellow('ask before changes'), plan: c.info('⏸ plan mode') }[ui.permission]) // Shift+Tab changes it
+    return [first.join(sep), second.join(sep)].filter((l) => l.replace(/\x1b\[[0-9;]*m/g, '').trim()).join('\n')
   }
 
   client(name, model) {
@@ -627,7 +685,13 @@ class App {
       ui.print(NO_MODELS)
       return null
     }
-    const { client, profile, strat } = await this.engine(cfg.provider, cfg.model, ui, this.signal)
+    // this session's models (a set you chose, else your list), first one whose provider is on
+    const start = this.sessionModels()[0]
+    if (!start) {
+      ui.print(ALL_OFF)
+      return null
+    }
+    const { client, profile, strat } = await this.engine(start.provider, start.model, ui, this.signal)
     this.s = new Session({ client, profile, strat, root: this.root, ui, chat: this.chat }) // details: the status bar
     this.s.autoCompact = cfg.autoCompact !== false
     this.s.onTurn = () => this.save()
@@ -644,12 +708,12 @@ class App {
     return this.s
   }
 
-  // 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 "auto") is used alone (cfg.fixed), then --fallback-model's.
+  // The session's models as a rotation on the client: this session's set (sessionModels), then
+  // --fallback-model's. One model: no rotation.
   useRotation() {
     const { cfg } = this
     const seen = new Set()
-    const list = [{ provider: cfg.provider, model: cfg.model }, ...(cfg.fixed ? [] : (cfg.rotation?.then ?? [])), ...(cfg.fallbacks ?? [])]
+    const list = [...this.sessionModels(), ...(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 ?? {})
@@ -666,8 +730,10 @@ class App {
   // Your other models (not the one in use) and what each can do, from its saved profile or
   // models.dev: nothing is sent to them to find out.
   team() {
-    const now = this.s?.client.rotation?.list[this.s.client.rotation.at] ?? this.myModels()[0]
-    return this.myModels()
+    // helpers use this session's models (the set you chose, else your list), minus the one in use —
+    // so a pinned single model gives no team, and a chosen set keeps helpers within it
+    const now = this.s?.client.rotation?.list[this.s.client.rotation.at] ?? this.sessionModels()[0]
+    return this.sessionModels()
       .filter((t) => !(t.provider === now?.provider && t.model === now?.model))
       .map((t) => ({ ...t, ...this.abilities(t) }))
   }
@@ -693,22 +759,62 @@ class App {
 
   // Your models, in order: this one (#1), then the fallbacks (chosen on /settings, where every
   // provider's whole list is).
-  myModels() {
+  // The model answering now: the model list's current one, the session's, or (none yet) the one it
+  // will start with: the first of yours whose provider is on (a model given for this run: that one).
+  // What the screen shows as "the model": never one of a provider that's switched off.
+  inUse() {
+    const { cfg } = this
+    const rot = this.s?.client.rotation
+    if (rot) return rot.list[rot.at]
+    if (this.s) return { provider: this.s.client.provider, model: this.s.client.model }
+    return this.sessionModels()[0] ?? null
+  }
+
+  // your list has models, but the providers of all of them are switched off
+  allOff() {
+    return !this.cfg.session && this.myModels(true).length > 0 && !this.myModels().length
+  }
+
+  // all: also the ones of a provider switched off (on the settings page), which are skipped otherwise
+  myModels(all = false) {
     const { cfg } = this
     const seen = new Set()
-    return [{ provider: cfg.provider, model: cfg.model }, ...(cfg.rotation?.then ?? [])].filter((t) => cfg.providers[t.provider] && t.model && !seen.has(`${t.provider}/${t.model}`) && seen.add(`${t.provider}/${t.model}`))
+    return [{ provider: cfg.provider, model: cfg.model }, ...(cfg.rotation?.then ?? [])].filter((t) => cfg.providers[t.provider] && (all || !cfg.providers[t.provider].off) && t.model && !seen.has(`${t.provider}/${t.model}`) && seen.add(`${t.provider}/${t.model}`))
   }
 
-  // Makes one of your models #1 (the rest keep their order); saved for next time.
-  async useMine(t) {
+  // The models THIS session uses: the set you chose with /select_model (cfg.session, session-local),
+  // else your whole list. One model: no rotation (pinned). Several: it rotates among just those.
+  sessionModels(all = false) {
     const { cfg } = this
-    delete cfg.fixed // one of your models: your list again, with its fallbacks
-    const rest = this.myModels().filter((x) => x.provider !== t.provider || x.model !== t.model)
-    cfg.rotation = { ...cfg.rotation, then: rest }
-    await this.use(t.provider, t.model)
+    if (!cfg.session) return this.myModels(all)
+    const seen = new Set()
+    return cfg.session.filter((t) => cfg.providers[t.provider] && (all || !cfg.providers[t.provider].off) && t.model && !seen.has(`${t.provider}/${t.model}`) && seen.add(`${t.provider}/${t.model}`))
   }
 
-  // The picker: your models only, #1 first; Enter makes it #1.
+  // Use a chosen set of models for this session: one pins it (no rotation), several rotate among
+  // just those. Remembered for this folder (.heartcode/models.json); the saved ranking is untouched.
+  async setSession(list) {
+    const { cfg } = this
+    cfg.session = list // the global #1 (cfg.provider/model) stays, so your whole list and the picker are unchanged
+    this.saveProjectModels()
+    this.s = null
+    this.ui.print(list.length === 1 ? `${c.green('using')} ${c.cyan(list[0].model)} ${c.dim('· pinned for this folder')}` : `${c.green(`using ${list.length} models for this folder`)}: ${c.cyan(list.map((t) => t.model).join(', '))}`)
+    await this.session()
+  }
+
+  // Back to auto: your whole list again (#1, then the next when one fails), following the saved
+  // ranking. The folder's remembered choice is cleared.
+  async auto() {
+    const { cfg } = this
+    delete cfg.session
+    this.saveProjectModels()
+    this.s = null
+    this.ui.print(`${c.green('using')} ${c.dim('auto')} ${c.cyan(`(${this.myModels().length} models)`)}`)
+    await this.session()
+  }
+
+  // The picker: tick the models for this session — one pins it, several rotate among them, all of
+  // them (or none) is the same as auto (your whole list). "auto" is the first entry.
   async chooseModel(filter = '') {
     const { ui, cfg } = this
     const mine = this.myModels()
@@ -716,20 +822,40 @@ class App {
       if (!Object.keys(cfg.providers).length && (await this.detectLocal())) return this.session()
       return ui.print(NO_MODELS)
     }
-    const items = mine.map((t, i) => ({ label: t.model, t, current: i === 0, desc: this.modelDesc(t, i) }))
-    const it = await ui.pick('Choose a model (more on /settings)', items, { filter })
-    if (it && !it.current) await this.useMine(it.t)
-  }
-
-  // "/select_model gpt-oss-120b" or "/select_model groq openai/gpt-oss-120b": one of your models;
-  // no argument, or one that's not in your list: the picker.
+    const key = (t) => `${t.provider}/${t.model}`
+    const chosen = new Set((cfg.session ?? mine).map(key)) // pre-ticked: this session's set, or all (auto)
+    const items = mine.map((t) => ({ label: t.model, t, checked: chosen.has(key(t)), desc: this.modelDesc(t, mine.indexOf(t)) }))
+    const picked = await ui.pick('Models for this session — tick several to rotate, one to pin (all = auto)', items, { filter, multi: true })
+    if (!picked) return
+    const list = picked.map((it) => it.t)
+    return list.length >= mine.length ? this.auto() : this.setSession(list)
+  }
+
+  // "/select_model a, b, c": use those models this session (one pins, several rotate). One model:
+  // "model", "provider model" or "provider/model". "/select_model auto": your whole list. No
+  // argument: the picker.
   async pickModel(args) {
     if (!args.length) return this.chooseModel()
-    const [name, model] = args.length > 1 ? [args[0], args.slice(1).join(' ')] : [null, args[0]]
-    const found = this.myModels().filter((t) => t.model === model && (!name || t.provider === name))
-    if (found.length === 1) return found[0].provider === this.cfg.provider && found[0].model === this.cfg.model ? this.ui.print(c.dim(`${model} is in use already`)) : this.useMine(found[0])
-    if (!found.length) this.ui.print(c.dim(`${model} isn't one of your models: add it on /settings`))
-    return this.chooseModel(found.length ? model : '')
+    if (args.every((a) => isAuto(a))) return this.cfg.session ? this.auto() : this.ui.print(c.dim('already on auto'))
+    const raw = args.join(' ')
+    const specs = raw.includes(',') ? raw.split(',').map((x) => x.trim()).filter(Boolean) : [raw]
+    const resolve = (spec) => {
+      const w = spec.trim().split(/\s+/)
+      const tries = [[null, spec.trim()], w.length > 1 && [w[0], w.slice(1).join(' ')], spec.includes('/') && [spec.slice(0, spec.indexOf('/')), spec.slice(spec.indexOf('/') + 1)]].filter(Boolean)
+      for (const [name, model] of tries) {
+        const hit = this.myModels().find((t) => t.model === model && (!name || t.provider === name))
+        if (hit) return hit
+      }
+      return null
+    }
+    const found = []
+    const missing = []
+    for (const spec of specs) (resolve(spec) ? found : missing).push(resolve(spec) ?? spec)
+    if (missing.length || !found.length) {
+      if (missing.length) this.ui.print(c.dim(`not in your models: ${missing.join(', ')} · add on /settings`))
+      return this.chooseModel(specs.length === 1 ? specs[0] : '')
+    }
+    return this.setSession(found)
   }
 
   listProviders() {
@@ -738,7 +864,7 @@ class App {
     if (!names.length) return ui.print(`No providers yet: add one with ${c.cyan('heart settings')}.`)
     for (const n of names) {
       const p = cfg.providers[n]
-      const notes = [n === cfg.provider && c.magenta('● current'), n === cfg.adhoc && c.dim('this run only')].filter(Boolean).join(' ')
+      const notes = [n === this.inUse()?.provider && c.magenta('● current'), p.off && c.yellow('off'), n === cfg.adhoc && c.dim('this run only')].filter(Boolean).join(' ')
       ui.print(`${c.bold(n.padEnd(14))} ${p.baseUrl}  ${c.dim(mask(p.apiKey))}  ${notes}`)
     }
   }
@@ -748,13 +874,13 @@ class App {
   // 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)
+  //     "providers": [{ "name", "baseUrl", "list": true, "off"?: 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) => ({ 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: [] }
+      const out = { name, baseUrl: p.baseUrl, list: p.list !== false, ...(p.off && { off: true }), models: [] }
       if (out.list) {
         try {
           out.models = await new Client({ baseUrl: p.baseUrl, apiKey: p.apiKey }).listModels()
@@ -843,7 +969,8 @@ async function continueTabs(app, saved) {
 // A continued tab's own model, as it was (unless its provider is gone: then the current one).
 function useModel(app, { provider, model }) {
   if (!provider || !model || (provider === app.cfg.provider && model === app.cfg.model)) return
-  if (!app.cfg.providers[provider]) return app.ui.warn(`this tab used ${provider} · ${model}, but there's no provider "${provider}" now: using ${app.cfg.provider} · ${app.cfg.model}`)
+  if (!app.cfg.providers[provider]) return app.ui.warn(`this tab used ${provider} · ${model}, but there's no provider "${provider}" now: using your list`)
+  if (app.cfg.providers[provider].off) return app.ui.warn(`this tab used ${provider} · ${model}, but ${provider} is switched off: using your list`)
   Object.assign(app.cfg, { provider, model })
   app.s = null
 }
@@ -872,13 +999,15 @@ function applySettings(apps, cfg, what) {
     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') {
+    // a model pinned in this CLI (/select_model) is a session choice: a model/order change on the
+    // settings page leaves it alone (only /select_model auto here returns it to the list)
+    if (what === 'model' && !app.cfg.session) {
       app.lists = {}
-      delete app.cfg.fixed // a model chosen on the page: your list again
       if (app.s && !(cfg.providers[cfg.provider] && cfg.model)) now(() => ((app.s = null), ui.print(c.dim('settings: no model chosen'))))
+      else if (app.s && !app.myModels().length) now(() => ((app.s = null), ui.print(c.dim('settings: the providers of all your models are switched off'))))
     }
     // 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) {
+    if ((what === 'model' || what === 'setting:rotation') && !app.cfg.session && 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}`
@@ -907,6 +1036,12 @@ function applySettings(apps, cfg, what) {
 // 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.
+// A model's profile fields a running HeartCode learns itself (context.js, the models.dev lookup); the
+// rest of the file is the settings page's.
+const LEARNED = ['inputLimit', 'inputLimitAt', 'cutAt', 'tokenRatio', 'largestAccepted', 'rateCap', 'known']
+// The settings as they are now, into every HeartCode in this process (watchSettings): run before each
+// request too, so a change the file watcher hasn't passed on yet (or never will) is still taken in.
+let syncSettings = () => {}
 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) => {
@@ -930,6 +1065,7 @@ function watchSettings(apps, cfg) {
   }
   let timer = null
   const check = () => {
+    clearTimeout(timer)
     timer = null
     configChanged()
     for (const [name, what] of Object.entries(WATCHED)) {
@@ -940,6 +1076,7 @@ function watchSettings(apps, cfg) {
       applySettings(apps(), cfg, what)
     }
   }
+  syncSettings = check
   try {
     const watcher = fs.watch(HOME, { recursive: true }, (_, file) => {
       const top = String(file ?? '').split(path.sep)[0]
@@ -991,14 +1128,6 @@ function leaveTabWorktree(app) {
   ui.print(`${c.dim('kept worktree')} ${c.info(wt.dir)} ${c.dim('on')} ${c.info(wt.branch)} ${c.faint(`· merge: git merge ${wt.branch} (commit in the worktree first)`)}`)
 }
 
-// The system clipboard (pbcopy, clip, wl-copy, xclip, xsel); else the terminal's (OSC 52, works over SSH too).
-function copyText(text) {
-  const tools = process.platform === 'darwin' ? [['pbcopy']] : process.platform === 'win32' ? [['clip']] : [['wl-copy'], ['xclip', '-selection', 'clipboard'], ['xsel', '-b', '-i']]
-  for (const [cmd, ...args] of tools) if (spawnSync(cmd, args, { input: text, stdio: ['pipe', 'ignore', 'ignore'] }).status === 0) return 'system'
-  process.stdout.write(`\x1b]52;c;${Buffer.from(text).toString('base64')}\x07`)
-  return 'osc'
-}
-
 // A model's profile: the saved one; else what models.dev says (nothing is sent to the model to
 // find out); a model it doesn't know: plain assumptions, until you set it up on the settings page.
 // force (/test_model, heart probe): test it now instead, with real requests.
@@ -1024,7 +1153,7 @@ async function getProfile(client, ui, force, signal, quiet = false) {
   const t0 = Date.now()
   const tested = await probe(client, (label) => ui.spinner(`testing: ${label}`), signal)
   ui.stopSpin()
-  ui.print(c.dim(`done in ${((Date.now() - t0) / 1000).toFixed(1)}s · saved to ${profilePath(client)}`))
+  ui.print(c.dim(`done in ${duration(Date.now() - t0)} · saved to ${profilePath(client)}`))
   return tested
 }
 
@@ -1038,6 +1167,8 @@ async function slash(app, line) {
   const [cmd, ...args] = line.slice(1).trim().split(/\s+/)
   const { ui, cfg } = app
   switch (cmd) {
+    case 'close_tab':
+      return void (await app.closeTab())
     case 'exit':
     case 'quit': {
       const n = app.tabs?.list.length ?? 1
@@ -1123,7 +1254,7 @@ async function slash(app, line) {
       const format = /\.html?$/i.test(file) ? 'html' : /\.json$/i.test(file) ? 'json' : 'md'
       const abs = path.resolve(app.root, file)
       fs.mkdirSync(path.dirname(abs), { recursive: true })
-      fs.writeFileSync(abs, exportChat(app.chat, format, cfg.model ? `${cfg.provider} · ${cfg.model}` : ''))
+      fs.writeFileSync(abs, exportChat(app.chat, format, app.inUse() ? `${app.inUse().provider} · ${app.inUse().model}` : ''))
       return ui.print(`${c.green('saved')} ${path.relative(app.root, abs) || abs}`)
     }
     case 'diff': {
@@ -1164,8 +1295,8 @@ async function slash(app, line) {
       ui.print(`${c.bold('tokens')}  ${kTokens(u.input)} in${u.cached ? ` (${kTokens(u.cached)} from the cache)` : ''} · ${kTokens(u.output)} out · ${u.requests} request${u.requests > 1 ? 's' : ''}`)
       return ui.print(
         u.priced
-          ? `${c.bold('cost')}    ${money(u.cost)}${price ? c.faint(`  (${cfg.model}: $${price.input ?? 0} in / $${price.output ?? 0} out per million tokens, from models.dev)`) : ''}`
-          : c.faint(`cost: not known for ${cfg.model ?? 'this model'} (models.dev doesn't list it; local and subscription models have none)`),
+          ? `${c.bold('cost')}    ${money(u.cost)}${price ? c.faint(`  (${app.inUse()?.model}: $${price.input ?? 0} in / $${price.output ?? 0} out per million tokens, from models.dev)`) : ''}`
+          : c.faint(`cost: not known for ${app.inUse()?.model ?? 'this model'} (models.dev doesn't list it; local and subscription models have none)`),
       )
     }
     case 'clear_chat': // a new session; the old one stays in /resume
@@ -1294,17 +1425,31 @@ async function repl(app, f = {}) {
     ui.close()
     process.exit(0)
   }
-  // Ctrl+Q: this tab (working: press it again to stop the work too); the last one quits
-  let lastClose = 0
-  ui.onCloseTab = () => {
-    if (ctl && Date.now() - lastClose > 2000) {
-      lastClose = Date.now()
-      return ui.notice('Still working: Ctrl+Q again stops it and closes this tab', 2000)
+  // Ctrl+Q, /close_tab: this tab, after asking (working: that stops too); the last one quits
+  let closing = false
+  app.closeTab = async (working = false) => {
+    if (closing) return
+    closing = true
+    try {
+      const last = (app.tabs?.list.length ?? 1) < 2
+      const go = await ui.pick(`Close this tab?${working ? ' It is still working: that stops too.' : ''}`, [
+        { label: 'Yes, close it', desc: last ? 'the last tab: HeartCode quits (it comes back next time)' : undefined, yes: true },
+        { label: 'No' },
+      ])
+      if (!go?.yes) return
+      if (last && app.tabs) app.tabs.quitting = true
+      ctl?.abort()
+      ui.cancelAsk()
+      ui.close()
+    } finally {
+      closing = false
     }
-    if (app.tabs.list.length < 2) app.tabs.quitting = true
-    ctl?.abort()
-    ui.cancelAsk()
-    ui.close()
+  }
+  ui.onCloseTab = () => {
+    if (closing) return
+    if (!ui.asking) return app.closeTab(true) // working: asked over the work
+    if (!ui.histOn || ui.menu.pick) return ui.notice('Answer this first, then Ctrl+Q', 2000)
+    ui.submit('/close_tab') // at the prompt: asked in its turn, like a typed /close_tab
   }
   const others = () => (app.tabs?.list.length ?? 1) - 1
   ui.onInterrupt = () => {
@@ -1328,7 +1473,7 @@ async function repl(app, f = {}) {
   const where = home && app.root.startsWith(home) ? '~' + app.root.slice(home.length) : app.root
   ui.header = (cols = 100) => [
     `${c.brand('♥')} ${c.bright(c.bold('HeartCode'))} ${c.faint(VERSION)}  ${c.muted(where.length > cols - 16 ? '…' + where.slice(-(cols - 17)) : where)}`,
-    [['/', 'commands'], ['@', 'files'], [NEWLINE_KEY, 'new line'], ['Esc', 'stop'], ['Shift+Tab', 'permissions'], ['Ctrl+R', 'voice']].map(([k, d]) => `${c.muted(k)} ${c.faint(d)}`).join(c.ghost(' · ')),
+    [['/', 'run a command'], ['@', 'attach a file'], [NEWLINE_KEY, 'add a new line'], ['Esc', 'stop'], ['Shift+Tab', 'change permissions']].map(([k, d]) => `${c.muted(k)} ${c.faint(d)}`).join(c.ghost(' · ')),
     '',
   ]
   if (!ui.full) ui.print(ui.header().join('\n'))
@@ -1376,6 +1521,7 @@ async function repl(app, f = {}) {
         ui.setPermission(go.mode)
         ok = await runTask(app, prompt('agent/plan-approved'), ctl)
       }
+      if (ui.busySince) ui.print(c.faint(c.italic(`✻ took ${duration(ui.worked())}`))) // fixed once the reply is in
     }
     ui.idle()
     ctl = null
@@ -1507,6 +1653,11 @@ async function main() {
     // Everything is allowed unless the user chose otherwise (saved), or --ask for this run.
     ui.permission = f['dangerously-skip-permissions'] ? 'all' : f['permission-mode'] ? PERMISSION_MODES[f['permission-mode']] : f.ask ? 'ask' : f.yes ? 'all' : (cfg.permissions ?? 'all')
     if (!headless) {
+      ui.queueMode = cfg.queue ?? 'all'
+      ui.onQueueMode = (mode) => {
+        cfg.queue = mode
+        saveConfig(cfg)
+      }
       ui.onPermission = (mode) => {
         if (mode === 'plan') return // for this session only: HeartCode doesn't start in plan mode
         cfg.permissions = mode

package/package.json

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