heartcode 0.1.6 → 0.1.7

package/src/guided.js

@@ -17,41 +17,15 @@ const ACTIONS = prompt('guided/actions')
   .map((l) => l.split(/:\s*/, 2))
   .filter(([n, d]) => n && d)
 const DESC = Object.fromEntries(ACTIONS)
-const CHANGE_WORDS = /\b(fix|add|change|implement|create|write|make|rename|refactor|update|remove|delete|replace|edit|convert|move|improve)\b/i
-const RUN_WORDS = /\b(tests?|run|build|lint|compile)\b/i
-const FAIL_WORDS = /\b(fail\w*|broken|breaks?|errors?|crash\w*)\b/i
 const TEST_FILE = /(^|[/._-])(tests?|spec|__tests__)([/._-]|$)/i
-const TESTS_ARE_TARGET = /\b(add|write|update|change|fix|edit)\s+(the\s+|a\s+|some\s+)?(unit\s+)?tests?\b/i
-const QUESTION = /^\s*(what|how|why|where|which|who|when|explain|describe|summari[sz]e|tell|show|list|is|are|does|do|can|could|should)\b|\?\s*$/i
-
-// Wording first; the model only breaks a tie (small models answer yes/no unreliably).
-export function intent(task) {
-  const change = CHANGE_WORDS.test(task)
-  const question = QUESTION.test(task)
-  return change && !question ? true : question && !change ? false : null
-}
-
-// A path in the task that doesn't exist yet, e.g. "create src/slug.js".
-export function newFileIn(task, files) {
-  if (!/\b(create|new|add|write|make|generate)\b/i.test(task)) return null
-  for (const m of task.matchAll(/(?:^|[\s`'"(])((?:[\w.-]+\/)*[\w-]+\.[a-z0-9]{1,6})(?=$|[\s`'"),:;]|\.(?:\s|$))/gi)) {
-    const f = m[1].replace(/^\.\//, '')
-    if (!files.includes(f) && !/^(node|next|vue|react|nuxt|express|three|d3)\.js$/i.test(f)) return f
-  }
-  return null
-}
 
 // Obvious next steps are taken without asking: a weak model's effort goes into
 // writing code, not into navigating. Returns an action, or null to ask.
 export function autoAction(st) {
   if (st.delegated) return 'finish' // another model did the task: say what it did
-  if (st.newFile && st.wantsChange) return 'create'
-  if (st.failing && st.canRun && !st.runs && !st.edits) return 'run' // see the failure first
   if (st.lastRun !== null && st.lastRun !== 0 && !st.editsSinceRun && st.wantsChange && st.fixes < 3) return 'edit'
   if (st.wantsChange && st.reads && !st.edits) return 'edit'
-  if (st.editsSinceRun && st.canRun && st.wantsRun) return 'run'
   if (st.lastRun === 0 && st.edits && !st.editsSinceRun) return 'finish'
-  if (st.wantsRun && !st.runs && !st.wantsChange) return 'run'
   return null
 }
 
@@ -294,13 +268,11 @@ class Guided {
   }
 
   async start(images) {
+    this.images = images.length > 0
     if (images.length) await this.describeImages(images)
     this.autoRead()
     this.ui.spinner('reading the task')
-    this.st.wantsChange = intent(this.task) ?? (await this.yesNo(prompt('guided/intent'), false))
-    this.st.newFile = newFileIn(this.task, this.files)
-    this.st.wantsRun = RUN_WORDS.test(this.task)
-    this.st.failing = FAIL_WORDS.test(this.task)
+    this.st.wantsChange = await this.yesNo(prompt('guided/intent'), false) // the model says, not words in the task
     let last = ''
     let repeats = 0
     // No step limit (Esc stops it); a model doing the same thing three times in a row is stopped.
@@ -410,11 +382,9 @@ class Guided {
     const seen = this.notes.filter((n) => n.key?.startsWith('read:')).map((n) => n.key.slice(5)).reverse()
     // Weak models pick the first option: offer the code under test before the tests themselves.
     let files = [...new Set([...seen, ...this.files])]
-    const testsAreTarget = TESTS_ARE_TARGET.test(this.task)
-    if (!testsAreTarget) files = [...files.filter((x) => !TEST_FILE.test(x)), ...files.filter((x) => TEST_FILE.test(x))]
+    files = [...files.filter((x) => !TEST_FILE.test(x)), ...files.filter((x) => TEST_FILE.test(x))]
     let f = await this.pickFile(prompt('guided/which-file-to-edit'), files)
     if (!f) return 'edit:'
-    if (this.st.lastRun && TEST_FILE.test(f) && !testsAreTarget) f = this.codeUnderTest(f)
     const old = fs.readFileSync(resolveIn(this.s.root, f), 'utf8')
     this.ui.step('edit', f)
     let next = null
@@ -425,24 +395,20 @@ class Guided {
     if (lost.length) {
       this.ui.result(c.yellow(`that edit deleted ${lost.join(', ')}; retrying`))
       const again = await this.editRewrite(f, old, prompt('guided/keep-names', { names: lost.join(', '), them: lost.length > 1 ? 'them' : 'it' }))
-      if (again !== null && !lostNames(old, again, this.task).length) next = again
-      else this.ui.warn(`this edit removes ${lost.join(', ')}; check the diff`)
+      const still = again === null ? lost : lostNames(old, again, this.task)
+      if (again !== null && !still.length) next = again
+      // still gone: written only if the model says the task asks for that (not from words in it)
+      else if (await this.yesNo(prompt('guided/meant-to-remove', { names: still.join(', ') }), false)) next = again ?? next
+      else return (this.failed(f, `the edit removed ${still.join(', ')}, which the task doesn't ask for`), `edit:${f}`)
     }
     await this.apply(f, old, next)
     return `edit:${f}`
   }
 
-  // Weak models "fix" failing tests by editing the tests. Unless the task asks for test changes,
-  // the edit goes to the code the test imports.
-  codeUnderTest(test) {
-    const code = localImports(test, fs.readFileSync(resolveIn(this.s.root, test), 'utf8'), this.files).find((x) => !TEST_FILE.test(x))
-    if (code) this.note(null, 'note', prompt('guided/note-tests-are-right', { test, code }))
-    return code ?? test
-  }
-
   async editBlocks(f, old) {
     const q = prompt('guided/edit-blocks', { file: f, content: fence(old) })
     const res = await this.query(q, { room: Math.min(est(old) + 800, 4096), onToken: this.progress(`editing ${f}`), skipKey: `read:${f}` })
+    if (this.unfinished(f, res)) return null
     const blocks = parseBlocks(res.content)
     let text = old
     for (const b of blocks) {
@@ -461,7 +427,7 @@ class Guided {
     if (est(old) * 2.3 + 1000 < this.s.strat.context) {
       const q = prompt('guided/rewrite', { file: f, content: fence(old), extra })
       const res = await this.query(q, { room: Math.ceil(est(old) * 1.5) + 600, onToken: this.progress(`rewriting ${f}`), skipKey })
-      if (res.finishReason === 'length') return this.failed(f, 'the reply was cut off before the end of the file')
+      if (this.unfinished(f, res)) return null
       return cleanCode(res.content, old)
     }
 
@@ -500,11 +466,20 @@ class Guided {
       extra,
     })
     const res = await this.query(q, { room: est(chunk) * 2 + 500, onToken: this.progress(`rewriting ${f}:${a}-${b}`), skipKey })
-    if (res.finishReason === 'length') return this.failed(f, 'the reply was cut off')
+    if (this.unfinished(f, res)) return null
     const repl = reindent(lines.slice(a - 1, b), cleanCode(res.content, chunk).split('\n'))
     return [...lines.slice(0, a - 1), ...repl, ...lines.slice(b)].join('\n')
   }
 
+  // A reply that can't be a whole file or edit: cut off (a length limit), stopped by a filter, or
+  // empty (all of it in the thinking). Nothing is written from it.
+  unfinished(f, res) {
+    if (res.finishReason === 'length') return this.failed(f, 'the reply was cut off') ?? true
+    if (res.finishReason === 'content_filter') return this.failed(f, 'the reply was stopped by the provider\'s filter') ?? true
+    if (!String(res.content ?? '').trim()) return this.failed(f, 'the reply was empty') ?? true
+    return false
+  }
+
   failed(f, why) {
     this.ui.result(c.red(`edit failed: ${why}`))
     this.note(null, `editing ${f} failed`, why)
@@ -526,12 +501,8 @@ class Guided {
   }
 
   async create() {
-    let rel = this.st.newFile
-    this.st.newFile = null
-    if (!rel) {
-      const res = await this.query(prompt('guided/new-file-path'), { room: 40, oneLine: true })
-      rel = unquote(answerText(res.content).split('\n')[0].trim())
-    }
+    const res = await this.query(prompt('guided/new-file-path'), { room: 40, oneLine: true })
+    const rel = unquote(answerText(res.content).split('\n')[0].trim())
     if (!rel) return 'create:'
     const abs = resolveIn(this.s.root, rel)
     const f = path.relative(this.s.root, abs)
@@ -546,8 +517,7 @@ class Guided {
       room: Math.min(4096, Math.floor(this.s.strat.context / 2)),
       onToken: this.progress(`writing ${f}`),
     })
-    if (r.finishReason === 'length') this.failed(f, 'the reply was cut off')
-    else await this.apply(f, '', cleanCode(r.content))
+    if (!this.unfinished(f, r)) await this.apply(f, '', cleanCode(r.content))
     return `create:${f}`
   }
 
@@ -588,8 +558,10 @@ class Guided {
 
   // Another of your models, one with tool calls, does the whole task; what it did goes in the notes.
   async delegate() {
-    const team = this.s.team().filter((t) => t.tools)
-    const t = (/\.(png|jpe?g|gif|webp)\b/i.test(this.task) && team.find((x) => x.images)) || team[0]
+    // the model with tool calls that failed least this session (and sees images, if the task came with some)
+    const fails = (t) => this.s.failures?.[`${t.provider} ${t.model}`] ?? 0
+    const team = this.s.team().filter((t) => t.tools).sort((a, b) => (this.images ? b.images - a.images : 0) || fails(a) - fails(b))
+    const t = team[0]
     const done = await this.s.subagent({ description: 'the task', prompt: this.task, model: `${t.provider} ${t.model}` }, this.signal)
     this.note('delegate', `what ${t.model} did for the task`, done)
     this.st.delegated = true

package/src/headless.js

@@ -12,7 +12,7 @@
 // told to the model. Logs and warnings go to stderr (and HEART_LOG), never stdout.
 import readline from 'node:readline'
 import { log } from './log.js'
-import { clip, TOOL_DEFS, extraTools, loadMcpTools } from './tools.js'
+import { clip, TOOL_DEFS, extraTools, loadMcpTools, failed as toolFailed } from './tools.js'
 import { allowed } from './agent.js'
 
 // Claude Code's tool names → HeartCode's (for --allowedTools / --disallowedTools).
@@ -97,11 +97,12 @@ export async function runHeadless(app, opts) {
   let usage = { input_tokens: 0, output_tokens: 0 }
   let byModel = {}
   let requests = 0
-  const count = (client, key) => {
+  // each request under the model that answered it (the model list may have moved on)
+  const count = (client) => {
     const chat = client.chat.bind(client)
     client.chat = async (...a) => {
       const r = await chat(...a)
-      const m = (byModel[key] ??= { inputTokens: 0, outputTokens: 0 })
+      const m = (byModel[`${client.provider}/${client.model}`] ??= { inputTokens: 0, outputTokens: 0 })
       if (client === s.client) requests++
       usage.input_tokens += r.usage?.prompt_tokens ?? 0
       usage.output_tokens += r.usage?.completion_tokens ?? 0
@@ -110,11 +111,11 @@ export async function runHeadless(app, opts) {
       return r
     }
   }
-  count(s.client, model)
+  count(s.client)
   const engineFor = s.engineFor
   if (engineFor) s.engineFor = async (t) => {
     const e = await engineFor(t)
-    count(e.client, `${t.provider}/${t.model}`)
+    count(e.client)
     return e
   }
 
@@ -129,9 +130,9 @@ export async function runHeadless(app, opts) {
         ]
         if (e.content && !e.parent) said = true
         // a helper's (agent) steps too, as Claude Code sends a subagent's: parent_tool_use_id is its agent call
-        if (content.length) emit({ type: 'assistant', message: { role: 'assistant', model: e.parent ? e.model : model, content }, parent_tool_use_id: e.parent ?? null, session_id })
+        if (content.length) emit({ type: 'assistant', message: { role: 'assistant', model: e.model ?? model, content }, parent_tool_use_id: e.parent ?? null, session_id })
       } else if (e.type === 'tool') {
-        emit({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: e.id, content: e.output, is_error: e.output.startsWith('error') }] }, parent_tool_use_id: e.parent ?? null, session_id })
+        emit({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: e.id, content: e.output, is_error: toolFailed(e.output) }] }, parent_tool_use_id: e.parent ?? null, session_id })
       }
     }
     if (s.strat.actions === 'tools' && s.mcp?.names.length) await loadMcpTools(s) // their tools are in the list, as in Claude Code's
@@ -164,9 +165,9 @@ export async function runHeadless(app, opts) {
     }
     const subtype = current.maxTurns ? 'error_max_turns' : error ? 'error_during_execution' : 'success' // as Claude Code names them
     current = null
-    const result = { type: 'result', subtype, is_error: Boolean(error), result: error ?? answer, num_turns: Math.max(1, requests), duration_ms: Date.now() - t0, total_cost_usd: (app.chat.usage?.cost ?? 0) - spent, usage, modelUsage: { [model]: { inputTokens: 0, outputTokens: 0 }, ...byModel }, session_id }
+    const result = { type: 'result', subtype, is_error: Boolean(error), result: error ?? answer, num_turns: Math.max(1, requests), duration_ms: Date.now() - t0, total_cost_usd: (app.chat.usage?.cost ?? 0) - spent, usage, modelUsage: Object.keys(byModel).length ? byModel : { [model]: { inputTokens: 0, outputTokens: 0 } }, session_id }
     if (out === 'stream-json') {
-      if (!error && answer && !said) emit({ type: 'assistant', message: { role: 'assistant', model, content: [{ type: 'text', text: answer }] }, parent_tool_use_id: null, session_id }) // guided mode
+      if (!error && answer && !said) emit({ type: 'assistant', message: { role: 'assistant', model: `${s.client.provider}/${s.client.model}`, content: [{ type: 'text', text: answer }] }, parent_tool_use_id: null, session_id }) // guided mode
       emit(result)
     } else if (out === 'json') emit(result)
     else if (error) process.stderr.write(`heartcode: ${error}\n`)
@@ -197,8 +198,14 @@ export async function runHeadless(app, opts) {
       continue
     }
     if (msg.type === 'control_request') {
-      if (msg.request?.subtype === 'interrupt') current?.ctl.abort()
-      emit({ type: 'control_response', response: { subtype: 'success', request_id: msg.request_id } })
+      // as Claude Code answers them: initialize (an SDK's first line), interrupt, a permission mode;
+      // any other is said to be unsupported, not taken as done
+      const kind = msg.request?.subtype
+      const ok = () => emit({ type: 'control_response', response: { subtype: 'success', request_id: msg.request_id } })
+      if (kind === 'interrupt') (current?.ctl.abort(), ok())
+      else if (kind === 'initialize') ok()
+      else if (kind === 'set_permission_mode' && PERMISSION_MODES[msg.request.mode]) (app.ui.setPermission(PERMISSION_MODES[msg.request.mode]), ok())
+      else emit({ type: 'control_response', response: { subtype: 'error', request_id: msg.request_id, error: `HeartCode doesn't support the control request "${kind ?? ''}"` } })
       continue
     }
     if (msg.type !== 'user') continue

package/src/hooks.js

@@ -45,7 +45,7 @@ const matches = (matcher, tool) => {
   if (!matcher || matcher === '*' || !tool) return true
   try {
     const re = new RegExp(`^(?:${matcher})$`)
-    return re.test(tool) || re.test(CLAUDE_NAMES[tool] ?? '') || (tool === 'mcp' && /^mcp__/.test(matcher))
+    return re.test(tool) || re.test(CLAUDE_NAMES[tool] ?? '')
   } catch {
     return matcher === tool
   }

package/src/mcp.js

@@ -120,6 +120,7 @@ class Server {
     log('mcp', `starting ${this.name}: ${command} ${args.join(' ')}`)
     const child = (this.child = spawn(command, args, { cwd: this.root ?? undefined, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'], detached: process.platform !== 'win32' })) // in the project, so a relative path in its config works
     let buf = ''
+    child.stdout.setEncoding('utf8') // a character split between two chunks stays whole
     child.stdout.on('data', (d) => {
       buf += d
       let nl
@@ -133,8 +134,11 @@ class Server {
     const gone = new Promise((_, reject) => {
       child.on('error', (e) => reject(new Error(`${this.name} could not start: ${e.message}`)))
       child.on('exit', (code) => {
-        this.ready = null
-        this.#failAll(new Error(`${this.name} stopped (exit ${code})`))
+        // a server started again since: this old one's exit is nothing to the new one
+        if (this.child === child) {
+          this.ready = null
+          this.#failAll(new Error(`${this.name} stopped (exit ${code})`))
+        }
         reject(new Error(`${this.name} stopped (exit ${code})`))
       })
     })
@@ -235,6 +239,8 @@ class Server {
         return log('mcp', `${this.name} sent a non-JSON line: ${line.slice(0, 200)}`)
       }
     }
+    // a long call saying it's still at work: its time to answer starts again
+    if (msg.method === 'notifications/progress') return this.pending.get(msg.params?.progressToken)?.alive?.()
     if (msg.id !== undefined && (msg.result !== undefined || msg.error) && this.pending.has(msg.id)) {
       const { resolve, reject } = this.pending.get(msg.id)
       this.pending.delete(msg.id)
@@ -249,13 +255,21 @@ class Server {
     }
   }
 
+  // timeout: how long it may go without answering, or saying it's still at work (a tool call asks
+  // for progress notifications; each one gives it the time again)
   request(method, params, timeout = 120_000, signal) {
     return new Promise((resolve, reject) => {
       const id = this.next++
-      const timer = setTimeout(() => {
-        this.pending.delete(id)
-        reject(new Error(`${this.name} did not answer ${method} within ${timeout / 1000}s`))
-      }, timeout)
+      let timer
+      const alive = () => {
+        clearTimeout(timer)
+        timer = setTimeout(() => {
+          this.pending.delete(id)
+          reject(new Error(`${this.name} did not answer ${method} within ${timeout / 1000}s`))
+        }, timeout)
+      }
+      alive()
+      if (method === 'tools/call') params = { ...params, _meta: { ...params?._meta, progressToken: id } }
       const done = (fn) => (v) => {
         clearTimeout(timer)
         signal?.removeEventListener('abort', onAbort)
@@ -266,7 +280,7 @@ class Server {
         done(reject)(Object.assign(new Error('stopped'), { name: 'AbortError' }))
       }
       signal?.addEventListener('abort', onAbort, { once: true })
-      this.pending.set(id, { resolve: done(resolve), reject: done(reject) })
+      this.pending.set(id, { resolve: done(resolve), reject: done(reject), alive })
       this.#send({ jsonrpc: '2.0', id, method, params })
     })
   }
@@ -277,7 +291,7 @@ class Server {
       this.tools = []
       let cursor
       do {
-        const r = await this.request('tools/list', cursor ? { cursor } : {})
+        const r = await this.request('tools/list', cursor ? { cursor } : {}, 120_000, signal)
         this.tools.push(...(r.tools ?? []))
         cursor = r.nextCursor
       } while (cursor)
@@ -296,6 +310,7 @@ class Server {
     if (this.url) {
       this.abort?.abort()
       Object.assign(this, { ready: null, session: null, endpoint: null })
+      this.#failAll(new Error(`${this.name} was stopped`))
       return
     }
     if (!this.child) return
@@ -305,6 +320,7 @@ class Server {
     } catch {}
     this.child = null
     this.ready = null
+    this.#failAll(new Error(`${this.name} was stopped`)) // calls waiting on it fail now (its exit comes later, ignored)
   }
 }
 

package/src/memory.js

@@ -18,13 +18,15 @@ import { HOME } from './config.js'
 
 export const TYPES = ['user', 'project', 'feedback', 'reference']
 const LINK = /\[\[([^\]|#]+)(?:[#|][^\]]*)?\]\]/g
-export const slug = (s) =>
-  String(s)
+// A note's file name (60 characters at most: a longer name is refused when written, tools.js, so
+// two long names that start alike can't become one note)
+export const fullSlug = (s) =>
+  String(s ?? '')
     .toLowerCase()
     .replace(/\.md$/, '')
     .replace(/[^a-z0-9]+/g, '-')
     .replace(/^-+|-+$/g, '')
-    .slice(0, 60) || 'note'
+export const slug = (s) => fullSlug(s).slice(0, 60) || 'note'
 
 // One folder of notes.
 class Notes {
@@ -71,7 +73,7 @@ class Notes {
 
   // Creates or replaces a note; returns its name.
   write({ name, description, type, tags, content }) {
-    const n = slug(name || description)
+    const n = slug(String(name ?? '').trim() || description)
     const old = this.read(n)
     const t = TYPES.includes(type) ? type : (old?.type ?? 'project')
     const d = String(description || old?.description || String(content).split('\n')[0]).replace(/\s+/g, ' ').trim().slice(0, 200)

package/src/probe.js

@@ -3,7 +3,7 @@ import path from 'node:path'
 import { deflateSync } from 'node:zlib'
 import { HOME, readJson, writeJson } from './config.js'
 import { est } from './client.js'
-import { contextWindow, contextSource, LOCAL_SERVERS, ASSUMED_REMOTE } from './context.js'
+import { contextWindow, contextSource, LOCAL_SERVERS, ASSUMED_REMOTE, LIMIT_MS } from './context.js'
 import { loadPrices, limitsOf } from './usage.js'
 import { applyEdit, parseBlocks } from './edit.js'
 import { c } from './ui.js'
@@ -107,6 +107,9 @@ async function runProbe(client, report = () => {}, signal) {
       return Boolean(await fn())
     } catch (e) {
       if (e.name === 'AbortError' || /^cannot reach/.test(e.message)) throw e
+      // no answer (a timeout, a stalled reply): nothing learned, nothing saved; an answer it can't
+      // read (not JSON) counts as "not supported" below
+      if (e.name === 'TimeoutError') throw new Error(`probe stopped, nothing saved: ${e.message}`)
       if ([401, 429].includes(e.status) || e.status >= 500 || ([403, 404].includes(e.status) && !calls))
         throw new Error(`probe stopped, nothing saved: ${e.message}`)
       lastError = e
@@ -297,7 +300,7 @@ export function strategy(p, cfg = {}) {
     toolsStream: stream && (said ? true : Boolean(p.toolsStream)),
     stop: said ? !thinking : Boolean(p.stop), // stop sequences cut into a thinking model's thinking
     mergeSystem: said ? false : !most(p.system),
-    vision: set.images ?? (said ? Boolean(said.images) : all(p.vision)),
+    vision: !(Date.now() - (p.quirks?.noImages ?? -Infinity) < LIMIT_MS) && (set.images ?? (said ? Boolean(said.images) : all(p.vision))), // its provider refused images this week: none
     thinking,
     context: cfg.context || set.context || win.size, // context.js: measured, said, models.dev, learned, or assumed
     contextSure: Boolean(cfg.context || set.context) || win.sure,
@@ -318,7 +321,7 @@ export function describe(p, s) {
   if (p.source) {
     const from = { 'models.dev': 'models.dev', you: 'you, on /settings', assumed: "nothing: it isn't in models.dev. Set what it can do on /settings" }[p.source]
     const mine = (k) => (p.set?.[k] !== undefined ? c.dim('  (set by you)') : '')
-    return [['from', from], context, ['tool calls', yn(s.actions === 'tools') + mine('tools')], ['thinking', yn(s.thinking) + mine('thinking')], ['images', yn(s.vision) + mine('images')], ['streaming', yn(s.stream) + mine('stream')]]
+    return [['from', from], context, ['tool calls', yn(s.actions === 'tools') + mine('tools')], ['thinking', yn(s.thinking) + mine('thinking')], ['images', yn(s.vision) + (Date.now() - (p.quirks?.noImages ?? -Infinity) < LIMIT_MS ? c.dim('  (its provider refused an image today)') : mine('images'))], ['streaming', yn(s.stream) + mine('stream')]]
       .map(([k, v]) => `  ${c.dim(k.padEnd(15))} ${v}`)
       .join('\n')
   }

package/src/settings.js

@@ -78,6 +78,21 @@ const ROTATION = { on: ['failure', 'retries', 'any'], next: ['first', 'stay'] }
 const rotationOf = (cfg) => ({ on: 'failure', retries: 2, next: 'first', ...cfg.rotation, then: (cfg.rotation?.then ?? []).filter((t) => cfg.providers[t.provider]) })
 
 const mask = (k) => (k ? (k.length > 12 ? `${k.slice(0, 4)}…${k.slice(-4)}` : '…') : '')
+async function schemeFor(address) {
+  try {
+    await fetch(`https://${address.replace(/\/+$/, '')}/models`, { redirect: 'manual', signal: AbortSignal.timeout(8000) })
+  } catch (e) {
+    // https can't connect at all (refused, or a server that only speaks http): http, if that answers
+    if (e.name !== 'TimeoutError') {
+      try {
+        await fetch(`http://${address.replace(/\/+$/, '')}/models`, { redirect: 'manual', signal: AbortSignal.timeout(8000) })
+        return `http://${address}`
+      } catch {}
+    }
+  }
+  return `https://${address}` // it answered on https, or is slow: never the key in the clear on a guess
+}
+
 const safeName = (n) => String(n ?? '').trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '')
 const skillsDir = () => path.join(HOME, 'skills')
 
@@ -191,11 +206,13 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
     'GET /api/state': () => state(),
     'GET /api/log-size': () => logSize(),
     'POST /api/clear-logs': () => ({ gone: clearLogs(), size: logSize() }),
-    'POST /api/provider': ({ name, baseUrl, apiKey, keepKey, was }) => {
+    'POST /api/provider': async ({ name, baseUrl, apiKey, keepKey, was }) => {
       name = safeName(name)
       if (!name) throw new Error('a name is needed')
       baseUrl = String(baseUrl ?? '').trim()
-      if (!/^https?:\/\//i.test(baseUrl)) baseUrl = (/^(localhost|127\.|0\.0\.0\.0|10\.|192\.168\.)/.test(baseUrl) ? 'http://' : 'https://') + baseUrl
+      // an address without http(s)://: whichever of the two the server answers on (any answer, even
+      // a 401, means it's there), https first
+      if (!/^https?:\/\//i.test(baseUrl)) baseUrl = await schemeFor(baseUrl)
       try {
         if (!new URL(baseUrl).hostname) throw new Error()
       } catch {