heartcode 0.1.1 → 0.1.5

package/SKILL.md

@@ -132,6 +132,11 @@ nothing is sent to the model to find out. A model models.dev doesn't know works
 assumptions, and the user can set it up on the settings page. Models that can't call tools still
 work, in a slower guided mode.
 
+The model in use knows the user's other models and what each can do, and hands a job it can't do
+(see an image, call tools…) to one that can: an attached image goes to a model that sees images, an
+image's path to one through its `agent` tool, and a model without tool calls can hand the task to one
+with them. Their tokens are in `usage`, and each model's in `modelUsage`.
+
 ## Setting up a model
 
 Ask the user which provider and model to use, and for the key. Never invent one. Then:

package/bin/heartcode.js

@@ -452,6 +452,13 @@ class App {
     return [...COMMANDS, ...mine]
   }
 
+  // A command: "/name …" with the name of a built-in command or a skill you can type. Anything else
+  // starting with "/" (a path like /Users/me/shot.png) is a message for the model.
+  isCommand(line) {
+    const name = /^\/([\w-]+)(?=\s|$)/.exec(line)?.[1]
+    return Boolean(name) && (name === 'quit' || this.commands().some(([n]) => n === `/${name}`))
+  }
+
   help() {
     const mine = this.commands().slice(COMMANDS.length)
     return helpText(mine.length ? [...SECTIONS, ['your skills', mine]] : SECTIONS)
@@ -502,7 +509,7 @@ class App {
   modelChoices(typed, start, end) {
     const mine = this.myModels()
     const twice = (m) => mine.filter((t) => t.model === m).length > 1
-    const items = mine.map((t, i) => ({ value: twice(t.model) ? `${t.provider} ${t.model}` : t.model, desc: `${t.provider} · #${i + 1}${i === 0 ? ' · in use' : ''}`, start, end }))
+    const items = mine.map((t, i) => ({ value: twice(t.model) ? `${t.provider} ${t.model}` : t.model, desc: `${t.provider} · #${i + 1}${i === 0 ? ' · in use' : ''} · ${this.canText(t)}`, start, end }))
     return rank(items, typed).slice(0, 200)
   }
 
@@ -585,6 +592,8 @@ class App {
     this.useRotation()
     Object.assign(this.s, { noFormat: cfg.format === false, noLsp: cfg.lsp === false })
     Object.assign(this.s, { mcp: this.mcp, memory: this.memory, skills: this.skills, director: this.director })
+    this.s.team = () => this.team() // your other models: a job this one can't do goes to one of them
+    this.s.engineFor = (t) => this.engine(t.provider, t.model, ui)
     if (this.allowTools?.length) this.s.allowTools = toolNames(this.allowTools) // headless --allowedTools
     if (this.denyTools?.length) this.s.denyTools = toolNames(this.denyTools)
     if (this.cfg.maxTurns) this.s.maxTurns = this.cfg.maxTurns
@@ -611,6 +620,29 @@ class App {
     await this.session()
   }
 
+  // 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()
+      .filter((t) => !(t.provider === now?.provider && t.model === now?.model))
+      .map((t) => ({ ...t, ...this.abilities(t) }))
+  }
+
+  // What a model can do, from its saved profile or models.dev (guessed: neither knows it).
+  abilities(t) {
+    const cl = this.client(t.provider, t.model)
+    const p = loadProfile(cl) || profileFrom(cl, limitsOf(t.provider, cl.baseUrl, t.model))
+    const st = strategy(p)
+    return { tools: st.actions === 'tools', images: st.vision, thinking: st.thinking, context: st.context, guessed: p.source === 'assumed' && !p.set }
+  }
+
+  // "tools · images · thinking · 1M", for the model lists.
+  canText(t) {
+    const a = this.abilities(t)
+    return [a.tools ? 'tools' : 'no tools', a.images && 'images', a.thinking && 'thinking', kTokens(a.context) + (a.guessed ? '?' : '')].filter(Boolean).join(' · ')
+  }
+
   // Your models, in order: this one (#1), then the fallbacks (chosen on /settings, where every
   // provider's whole list is).
   myModels() {
@@ -636,7 +668,7 @@ 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, group: t.provider, t, current: i === 0, desc: [i === 0 ? '#1 · in use' : `#${i + 1} · fallback`, loadProfile(this.client(t.provider, t.model)) && '✓ tested'].filter(Boolean).join(' · ') }))
+    const items = mine.map((t, i) => ({ label: t.model, group: t.provider, t, current: i === 0, desc: [i === 0 ? '#1 · in use' : `#${i + 1} · fallback`, this.canText(t)].join(' · ') }))
     const it = await ui.pick('Choose a model (more on /settings)', items, { filter })
     if (it && !it.current) await this.useMine(it.t)
   }
@@ -1235,6 +1267,8 @@ async function repl(app, f = {}) {
   let ctl = null
   ui.onEscape = () => ctl?.abort()
   ui.onBtw = (q) => app.btw(q, true) // /btw typed while it works
+  ui.isCommand = (l) => app.isCommand(l)
+  loadPrices().then(() => ui.render?.()) // models.dev: what each model can do, for the model lists
   ui.voiceConfig = () => ({ voice: cfg.voice, providers: cfg.providers })
   // Ctrl+C: stops what's running; clears the input if there's text; otherwise asks before quitting
   // (a second Ctrl+C within 2s quits, also when something is stuck).
@@ -1303,7 +1337,7 @@ async function repl(app, f = {}) {
     ctl = new AbortController()
     app.signal = ctl.signal // Esc stops whatever this line started (a task, a probe, …)
     ui.busy() // the spinner stays until this line's work is done
-    if (t.startsWith('/')) {
+    if (app.isCommand(t)) {
       try {
         if ((await slash(app, t)) === 'exit') {
           if (app.tabs) app.tabs.quitting = true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heartcode",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "description": "A coding CLI for any local or OpenAI-compatible model, including small models without tool calling.",
   "type": "module",
   "bin": {

package/prompts/agent.md

@@ -170,6 +170,30 @@ The user didn't answer. Decide yourself, carry on, and say in your reply what yo
 <!-- Starts a helper agent (only in the main conversation, not in helpers). -->
 Hand a side job to a helper agent with its own fresh context, so the details stay out of this conversation: searching or reading a lot of code to answer a question, researching on the web, reviewing changes. It has the same tools (no helpers of its own) and sees only your prompt, so say exactly what to do and what to report. Its final reply comes back as the result. description: 3-5 words for the user.
 
+Several agent calls in one reply run at the same time. Use that to split independent work (one helper per part), or to ask several helpers the same thing (different models, or the same one more than once) and combine their answers: compare them, keep what they agree on, check where they differ.
+
+## tool-agent-model
+
+<!-- The agent tool's "model", there when the user has other models. -->
+Another of your models to do the job (from "Your other models" in the system prompt, as "provider model"), when it needs what you can't do or you want its view too. Leave out for a helper on your own model.
+
+## team
+
+<!-- In the system prompt when the user set up other models. {{models}}: one per line with what each can do. {{you}}: what this model can do. -->
+# Your other models
+
+The user set up these models besides you (you: tool calls, {{you}}):
+{{models}}
+
+You can hand a job to one of them with the agent tool and its "model", and to several at once (several agent calls in one reply), for a second opinion or to compare answers. Never decline a part of the task, or say you can't do it, because it needs something you can't do (see an image, call tools, think longer, read more than fits your context): give that part to a model here that can, with everything it needs in the prompt (file paths, what to look for, what to report), then go on with its answer. Answering yourself is better when you can.
+
+## images-described
+
+<!-- Added to the user's message when this model can't see images and another of theirs described them. {{model}}: that model. {{descriptions}}: what it saw. -->
+(You can't see images, so {{model}} looked at the attached image(s) for you:
+
+{{descriptions}})
+
 ## subagent
 
 <!-- Added to a helper agent's system prompt. -->

package/prompts/guided.md

@@ -36,6 +36,7 @@ edit: change an existing file
 create: make a new file
 run: run a shell command (tests, build, scripts)
 ask: ask the user a question
+delegate: hand the task to another of your models, one that can use tools itself
 finish: stop and give your final answer to the user
 
 ## next-action

package/src/agent.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import os from 'node:os'
 import { log } from './log.js'
 import { prompt, userInstructions } from './prompts.js'
 import { newChat } from './sessions.js'
@@ -12,13 +13,16 @@ import { c } from './ui.js'
 
 const MIME = { png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp' }
 
-// "@shot.png" in a task attaches that image.
+// An image the message names is attached: "@shot.png", or a path anywhere (/Users/me/Downloads/a.png,
+// ~/a.png; dragged in: quoted, or with "\ " for spaces), when the file is there. The path stays in the text.
+const IMAGE_PATH = /(^|\s)@?(?:(["'])([^"'\n]+?\.(?:png|jpe?g|gif|webp))\2|((?:\\ |[^\s"'])+?\.(?:png|jpe?g|gif|webp)))(?=$|[\s,;:!?).])/gi
 export function extractImages(task, root) {
   const images = []
-  const text = task.replace(/(^|\s)@(\S+\.(png|jpe?g|gif|webp))\b/gi, (m, pre, file, ext) => {
+  const text = task.replace(IMAGE_PATH, (m, pre, q, quoted, bare) => {
+    const file = (quoted ?? bare.replace(/\\ /g, ' ')).replace(/^~(?=\/)/, os.homedir())
     const abs = path.resolve(root, file)
-    if (!fs.existsSync(abs)) return m
-    images.push(`data:${MIME[ext.toLowerCase()]};base64,${fs.readFileSync(abs).toString('base64')}`)
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return m
+    images.push(`data:${MIME[path.extname(abs).slice(1).toLowerCase()]};base64,${fs.readFileSync(abs).toString('base64')}`)
     return `${pre}${file}`
   })
   return { text, images }
@@ -137,7 +141,9 @@ export class Session {
     let { text, images } = extractImages(task, this.root)
     images = [...images, ...extra]
     if (images.length && !this.strat.vision) {
-      this.ui.warn(`${this.client.model} can't read images (per its probe); ignoring ${images.length} image(s)`)
+      const seer = this.team?.().find((t) => t.images) // another of your models that can: it describes them
+      if (seer) text += await this.describeImages(images, seer, text, signal)
+      else this.ui.warn(`${this.client.model} can't read images (per its probe); ignoring ${images.length} image(s)`)
       images = []
     }
     log('task', `${text} (${this.strat.actions} mode, ${images.length} image(s))`)
@@ -152,19 +158,42 @@ export class Session {
   // own, no memory, no director) does one job; its final reply is the tool's result. Its steps show
   // under the main conversation's, its file changes count for /rewind like the main agent's.
   // ponytail: helpers run one after another; run several at once if waiting on them gets long.
+  // model: another of your models (team) does it, for what this one can't do (see images, call tools…).
   async subagent(args, signal) {
     const task = String(args.prompt ?? args.task ?? '').trim()
     if (!task) return 'error: give the helper its job in "prompt"'
-    const label = clip(String(args.description ?? '').trim() || task.split('\n')[0], 40)
-    const helper = new Session({ client: this.client, profile: this.profile, strat: this.strat, root: this.root, ui: helperUI(this.ui, label), chat: newChat(this.root) })
+    let { client, profile, strat } = this
+    const want = String(args.model ?? '').trim()
+    if (want) {
+      const team = this.team?.() ?? []
+      const t = team.find((x) => `${x.provider} ${x.model}` === want) ?? team.find((x) => x.model === want || want.endsWith(` ${x.model}`))
+      if (t) ({ client, profile, strat } = await this.engineFor(t))
+      else if (want !== client.model && !want.endsWith(` ${client.model}`)) return `error: no model "${want}". Yours: ${[client.model, ...team.map((x) => `${x.provider} ${x.model}`)].join(', ')}`
+    }
+    const label = clip(`${client.model}: ${String(args.description ?? '').trim() || task.split('\n')[0]}`, 60)
+    const helper = new Session({ client, profile, strat, root: this.root, ui: helperUI(this.ui, label), chat: newChat(this.root) })
     Object.assign(helper, { isSub: true, mcp: this.mcp, skills: this.skills, hooks: this.hooks, allowTools: this.allowTools, denyTools: this.denyTools, maxTurns: this.maxTurns, autoCompact: this.autoCompact, appendSystem: this.appendSystem, fileCache: this.fileCache, noFormat: this.noFormat, noLsp: this.noLsp })
     helper.track = (rel, before) => this.track(rel, before)
     log('agent', `helper "${label}": ${task}`)
-    const answer = await runNative(helper, task, [], signal)
+    const answer = await (strat.actions === 'tools' ? runNative : runGuided)(helper, task, [], signal)
     log('agent', `helper "${label}" done`, answer)
     return answer?.trim() || '(the helper finished without a reply)'
   }
 
+  // Images for a model that can't see them: another of yours (seer) describes each, for the task.
+  async describeImages(images, seer, task, signal) {
+    const { client } = await this.engineFor(seer)
+    const out = []
+    for (const [i, url] of images.entries()) {
+      this.ui.spinner(`${seer.model} is looking at image ${i + 1}`)
+      const res = await client.chat({ messages: [{ role: 'user', content: [{ type: 'text', text: prompt('guided/describe-image', { task }) }, { type: 'image_url', image_url: { url } }] }] }, { signal })
+      out.push(`Image ${i + 1}:\n${res.content.trim()}`)
+      this.ui.step('image', `${seer.model} described image ${i + 1}`)
+    }
+    log('images', `described by ${seer.provider} ${seer.model}`, out)
+    return `\n\n${prompt('agent/images-described', { model: seer.model, descriptions: out.join('\n\n') })}`
+  }
+
   // /btw: a side question, answered from the conversation so far. Nothing goes into the
   // conversation and no tools are offered, so it can run while a task works: on its own client,
   // so the task's request timer and retries are left alone (its cost still counts).
@@ -282,6 +311,7 @@ const SYSTEM = (s) => {
     s.memory && prompt('agent/memory', { tags: s.memory.tagSummary() || '(none yet)' }),
     s.mcpInstructions && prompt('agent/mcp-instructions', { instructions: s.mcpInstructions }), // what the MCP servers say about their tools
     s.director && !s.appendSystem && s.director.app.cfg.director !== false && prompt('agent/director'),
+    !s.isSub && teamPrompt(s),
     s.isSub && prompt('agent/subagent'),
     s.appendSystem && prompt('agent/caller'),
     s.appendSystem,
@@ -290,6 +320,15 @@ const SYSTEM = (s) => {
     .join('\n\n')
 }
 
+// Your other models and what each can do, for the agent tool's model (only when there are any).
+const teamPrompt = (s) => {
+  const team = s.team?.() ?? []
+  if (!team.length) return ''
+  const can = (t) => [t.tools ? 'tool calls' : 'no tool calls', t.images && 'images', t.thinking && 'thinking', `${Math.round(t.context / 1000)}k context`].filter(Boolean).join(', ')
+  const you = [s.strat.vision ? 'images' : 'no images', s.strat.thinking && 'thinking'].filter(Boolean).join(', ')
+  return prompt('agent/team', { models: team.map((t) => `- ${t.provider} ${t.model}: ${can(t)}`).join('\n'), you })
+}
+
 const sizeOf = (m) =>
   (Array.isArray(m.content) ? m.content.reduce((n, p) => n + (p.type === 'text' ? est(p.text) : 800), 0) : est(m.content)) +
   (m.tool_calls ? est(JSON.stringify(m.tool_calls)) : 0) +
@@ -506,7 +545,7 @@ async function runNative(s, task, images, signal) {
     fitMessages(s.messages, budget())
     pairTools(s.messages)
     ui.spinner('thinking')
-    const out = ui.response()
+    const out = ui.response(client.model) // named: helpers think too (theirs are named in helperUI)
     const stream = strat.toolsStream
     let res
     try {
@@ -565,12 +604,25 @@ async function runNative(s, task, images, signal) {
       continue
     }
 
+    // Helpers (agent) asked for in one reply work at the same time: the same model or several.
+    // ponytail: no cap on how many at once; add one if a provider's rate limit makes them crawl.
+    const argsOf = (call) => {
+      try {
+        return JSON.parse(call.function.arguments || '{}')
+      } catch {
+        return null
+      }
+    }
+    const together = new Map()
+    for (const call of res.toolCalls) {
+      const args = argsOf(call)
+      if (call.function.name !== 'agent' || !args || !allowed(s, 'agent') || res.toolCalls.filter((x) => x.function.name === 'agent').length < 2) continue
+      ui.step('agent', clip([args.model && `${args.model}:`, args.description].filter(Boolean).join(' '), 80))
+      together.set(call.id, runTool('agent', args, s, signal))
+    }
     for (const call of res.toolCalls) {
       const name = call.function.name
-      let args = null
-      try {
-        args = JSON.parse(call.function.arguments || '{}')
-      } catch {}
+      const args = argsOf(call)
       const detail = !args
         ? ''
         : args.server
@@ -580,12 +632,12 @@ async function runNative(s, task, images, signal) {
             : name === 'manage'
               ? [args.action, args.kind, args.name].filter(Boolean).join(' ')
               : name === 'agent'
-                ? (args.description ?? '')
+                ? [args.model && `${args.model}:`, args.description].filter(Boolean).join(' ')
                 : name === 'todo' || name === 'ask_user'
                   ? ''
                   : (args.path ?? args.url ?? args.query ?? args.filter ?? args.name ?? '')
-      if (name !== 'run_command') ui.step(name, clip(detail, 80))
-      const out = !allowed(s, name) ? `error: the tool ${name} is not allowed here` : args ? await runTool(name, args, s, signal) : 'error: the tool arguments were not valid JSON'
+      if (name !== 'run_command' && !together.has(call.id)) ui.step(name, clip(detail, 80))
+      const out = together.has(call.id) ? await together.get(call.id) : !allowed(s, name) ? `error: the tool ${name} is not allowed here` : args ? await runTool(name, args, s, signal) : 'error: the tool arguments were not valid JSON'
       if (name === 'read_file' || name === 'search' || name === 'list_files' || name === 'web_fetch' || name === 'web_search') ui.result(`${out.split('\n').length} lines`)
       else if (name === 'agent' && !out.startsWith('error')) ui.result(`${s.ui.permission === 'plan' ? 'planned' : 'done'}: ${clip(out.split('\n').find((l) => l.trim()) ?? '', 100)}`)
       else if (out.startsWith('error')) ui.result(clip(out, 120))
@@ -618,13 +670,36 @@ async function notDone(s, signal, again) {
 
 // A helper agent's view of the screen: its steps are labelled, and its replies (which go to the
 // main agent) aren't shown as answers. Everything else is the main UI's.
+// Its thinking is shown whole when its reply is in (helpers working at once don't mix), named.
+// Questions to the user (confirm, pick, ask) wait their turn: helpers working at once ask one by one.
+const asking = new WeakMap() // ui → the question being asked
 function helperUI(ui, label) {
-  const quiet = { think() {}, text() {}, end() {} }
+  const response = () => {
+    const t0 = Date.now()
+    let thought = ''
+    return {
+      think: (t) => (thought += t ?? ''),
+      text() {},
+      end() {
+        if (!thought.trim()) return
+        const secs = ((Date.now() - t0) / 1000).toFixed(1)
+        ui.print(c.faint(c.italic(`  ✻ ${label} thought for ${secs}s`)) + (ui.showThinking ? `\n${c.think(c.italic(thought.trim().replace(/^/gm, '    ')))}` : ''))
+      },
+    }
+  }
+  const inTurn = (k) => (...a) => {
+    const next = (asking.get(ui) ?? Promise.resolve()).then(() => ui[k](...a))
+    asking.set(ui, next.catch(() => {}))
+    return next
+  }
   const own = {
     step: (name, detail) => ui.step(`  ${label} › ${name}`, detail),
     result: (text) => ui.result(`  ${text}`),
-    response: () => quiet,
+    response,
     spinner: (text) => ui.spinner(`${label} · ${text}`),
+    confirm: inTurn('confirm'),
+    pick: inTurn('pick'),
+    ask: inTurn('ask'),
   }
   return new Proxy(ui, { get: (t, k) => (k in own ? own[k] : typeof t[k] === 'function' ? t[k].bind(t) : t[k]), set: (t, k, v) => ((t[k] = v), true) })
 }
@@ -684,7 +759,7 @@ function attachNamed(s, task) {
     } catch {
       continue
     }
-    if (body.startsWith('error')) continue
+    if (body.startsWith('error') || body.startsWith(`${f} is a binary file`)) continue // an image: read_file shows it, or says who can see it
     const id = `named_${Date.now().toString(36)}_${calls.length}`
     calls.push({ id, type: 'function', function: { name: 'read_file', arguments: JSON.stringify({ path: f }) } })
     const msg = { role: 'tool', tool_call_id: id, content: body }

package/src/guided.js

@@ -44,6 +44,7 @@ export function newFileIn(task, files) {
 // 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'
@@ -61,7 +62,7 @@ export function nextActions(st) {
   if (!st.reads && st.hasFiles) first = ['read', 'search']
   else if (st.wantsChange && !st.edits) first = st.hasFiles ? ['edit', 'create', 'read'] : ['create']
   else first = ['finish', 'edit', 'run']
-  return [...new Set([...first, ...ACTIONS.map(([n]) => n)])]
+  return [...new Set([...first, ...ACTIONS.map(([n]) => n)])].filter((n) => n !== 'delegate' || st.canDelegate)
 }
 
 // A reply may be plain text or (when enforced) JSON like {"path": "a.js"}.
@@ -193,7 +194,7 @@ class Guided {
     this.notes = []
     this.changed = new Set()
     this.files = listFiles(s.root)
-    this.st = { reads: 0, edits: 0, editsSinceRun: 0, runs: 0, fixes: 0, lastRun: null, hasFiles: this.files.length > 0, canRun: suggestCommands(s.root).length > 0 }
+    this.st = { reads: 0, edits: 0, editsSinceRun: 0, runs: 0, fixes: 0, lastRun: null, hasFiles: this.files.length > 0, canRun: suggestCommands(s.root).length > 0, canDelegate: Boolean(s.team?.().some((t) => t.tools)) }
   }
 
   async yesNo(question, fallback) {
@@ -585,6 +586,16 @@ class Guided {
     return `ask:${q}`
   }
 
+  // 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]
+    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
+    return 'delegate'
+  }
+
   async finish() {
     this.ui.spinner('writing answer')
     let res

package/src/headless.js

@@ -93,15 +93,29 @@ export async function runHeadless(app, opts) {
   const model = `${app.cfg.provider}/${s.client.model}`
 
   // usage and request count, over everything this message sends (tool loop, compaction, memory)
+  // (also your other models', when this one hands them a job: modelUsage has each)
   let usage = { input_tokens: 0, output_tokens: 0 }
+  let byModel = {}
   let requests = 0
-  const chat = s.client.chat.bind(s.client)
-  s.client.chat = async (...a) => {
-    const r = await chat(...a)
-    requests++
-    usage.input_tokens += r.usage?.prompt_tokens ?? 0
-    usage.output_tokens += r.usage?.completion_tokens ?? 0
-    return r
+  const count = (client, key) => {
+    const chat = client.chat.bind(client)
+    client.chat = async (...a) => {
+      const r = await chat(...a)
+      const m = (byModel[key] ??= { 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
+      m.inputTokens += r.usage?.prompt_tokens ?? 0
+      m.outputTokens += r.usage?.completion_tokens ?? 0
+      return r
+    }
+  }
+  count(s.client, model)
+  const engineFor = s.engineFor
+  if (engineFor) s.engineFor = async (t) => {
+    const e = await engineFor(t)
+    count(e.client, `${t.provider}/${t.model}`)
+    return e
   }
 
   let said = false // the model's text was already sent as an assistant message
@@ -129,6 +143,7 @@ export async function runHeadless(app, opts) {
     const t0 = Date.now()
     const spent = app.chat.usage?.cost ?? 0
     usage = { input_tokens: 0, output_tokens: 0 }
+    byModel = {}
     requests = 0
     said = false
     current = { ctl: new AbortController() }
@@ -148,7 +163,7 @@ 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: usage.input_tokens, outputTokens: usage.output_tokens } }, 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: { [model]: { inputTokens: 0, outputTokens: 0 }, ...byModel }, session_id }
     if (out === 'stream-json') {
       if (!error && answer && !said) emit({ type: 'assistant', message: { role: 'assistant', model, content: [{ type: 'text', text: answer }] }, session_id }) // guided mode
       emit(result)

package/src/log.js

@@ -28,14 +28,23 @@ export function stamp(d = new Date()) {
 }
 // Logs older than `days` go: run folders, request folders, and the older one-file-per-run logs.
 // Returns how many went.
-export function pruneLogs(days = DAYS) {
-  const before = Date.now() - days * 86_400_000
+// When a log was last written to: a folder's newest file (writing into a file leaves its folder's
+// time as it was).
+function lastWritten(at) {
+  const s = fs.statSync(at)
+  if (!s.isDirectory()) return s.mtimeMs
+  let t = s.mtimeMs
+  for (const f of fs.readdirSync(at)) t = Math.max(t, fs.statSync(path.join(at, f), { throwIfNoEntry: false })?.mtimeMs ?? 0)
+  return t
+}
+
+export function pruneLogs(days = DAYS, before = Date.now() - days * 86_400_000) {
   let gone = 0
   for (const [dir, isLog] of [[path.join(LOGS, 'runs'), () => true], [REQUESTS, () => true], [LOGS, (f) => f.endsWith('.log')]]) {
     try {
       for (const f of fs.readdirSync(dir)) {
         const at = path.join(dir, f)
-        if (!isLog(f) || at === LOG_DIR || at === requestLog.dir || fs.statSync(at).mtimeMs >= before) continue
+        if (!isLog(f) || at === LOG_DIR || at === requestLog.dir || lastWritten(at) >= before) continue
         fs.rmSync(at, { recursive: true, force: true })
         gone++
       }
@@ -43,6 +52,31 @@ export function pruneLogs(days = DAYS) {
   }
   return gone
 }
+// The settings page's Delete all: every log but the ones being written now (this run's, and any
+// touched in the last minute: another HeartCode's). Returns how many files and folders went.
+export const clearLogs = () => pruneLogs(0, Date.now() - 60_000)
+
+// How much room the logs take on disk, in bytes: { runs, requests, total } (runs: the run logs,
+// and older single log files).
+export function logSize() {
+  const sum = (dir) => {
+    let n = 0
+    try {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        const at = path.join(dir, e.name)
+        n += e.isDirectory() ? sum(at) : (fs.statSync(at, { throwIfNoEntry: false })?.size ?? 0)
+      }
+    } catch {}
+    return n
+  }
+  let loose = 0
+  try {
+    for (const f of fs.readdirSync(LOGS)) if (f.endsWith('.log')) loose += fs.statSync(path.join(LOGS, f), { throwIfNoEntry: false })?.size ?? 0
+  } catch {}
+  const runs = sum(path.join(LOGS, 'runs')) + loose
+  const requests = sum(REQUESTS)
+  return { runs, requests, total: runs + requests }
+}
 export const logDays = (cfg) => (Number.isInteger(cfg.logDays) && cfg.logDays > 0 ? cfg.logDays : DAYS)
 
 // Which tab this is running for (tabs.js runs each tab's work in it): its log file, its requests.

package/src/settings.html

@@ -42,6 +42,9 @@
   .page { display: none; }
   .page.on { display: block; }
   .head { display: flex; align-items: flex-end; justify-content: space-between; gap: 16px; margin-bottom: 22px; flex-wrap: wrap; }
+  .disk { text-align: right; display: flex; flex-direction: column; align-items: flex-end; gap: 4px; }
+  .disk b { font-size: 22px; }
+  .disk .k { color: var(--muted); font-size: 12.5px; }
   h1 { font-size: 24px; margin: 0 0 4px; }
   .lead { color: var(--muted); margin: 0; max-width: 760px; }
   h2 { font-size: 15px; margin: 0 0 4px; }
@@ -412,7 +415,7 @@
 
     <!-- Logging -->
     <section class="page" id="page-logging">
-      <div class="head"><div><h1>Logging</h1><p class="lead">What HeartCode writes down, for finding out what went wrong. Off unless you switch it on.</p></div></div>
+      <div class="head"><div><h1>Logging</h1><p class="lead">What HeartCode writes down, for finding out what went wrong. Off unless you switch it on.</p></div><div class="disk" id="l-disk"></div></div>
       <div class="card">
         <div class="log-opts">
           <div>
@@ -606,6 +609,7 @@ function showPage() {
   for (const p of PAGES) $('page-' + p).classList.toggle('on', p === page())
   for (const a of document.querySelectorAll('nav a')) a.classList.toggle('on', a.dataset.page === page())
   if (S) drawUsing(S)
+  if (page() === 'logging') drawDisk()
   scrollTo(0, 0)
   fillHeight()
   document.querySelector('nav a.on')?.scrollIntoView({ inline: 'center', block: 'nearest' }) // on a phone the pages scroll sideways
@@ -805,7 +809,7 @@ function testLine(t) {
   const edit = (label) => h('button', { className: 'small', textContent: label, onclick: (e) => (e.stopPropagation(), openSetup(t)) })
   const [cls, text, action] =
     !x ? ['none', 'looking it up in models.dev…', null]
-      : x.source === 'assumed' ? ['warn', 'not in models.dev', edit('Set up')] // its Retry: on the Your models page, and Retry all
+      : x.source === 'assumed' ? ['warn', 'not in models.dev', edit('Set up')] // its Retry: on the Your models page, and Refresh from models.dev
       : ['ok', `✓ ${testedText(x)} · ${Object.keys(x.set ?? {}).length ? 'yours' : FROM[x.source]}`, edit('Edit')]
   const about = x?.source === 'assumed' ? "not in models.dev: Retry, or set up what it can do" : text
   return h('div', { className: 'test ' + cls }, h('span', { className: 'msg', textContent: text, title: about }), action)
@@ -876,7 +880,7 @@ async function tryAll() {
   toast(`${good} of ${list.length} work${good === list.length ? '' : `; ${list.length - good} don't (Works? says why, on hover)`}`, good < list.length)
 }
 
-// models.dev looked up again: one model (its Retry), or all of yours (Retry all)
+// models.dev looked up again: one model (its Retry), or all of yours (Refresh from models.dev)
 const retry = (t) => h('button', { className: 'small', textContent: 'Retry', title: 'look it up in models.dev again', onclick: (e) => (e.stopPropagation(), lookUp(t)) })
 async function lookUp(t) {
   toast(t ? `looking up ${t.model} in models.dev…` : 'looking up your models in models.dev…')
@@ -993,7 +997,7 @@ function drawProviders(s) {
       h('div', { className: 'mine-title' },
         h('h2', { textContent: 'Your models' }),
         h('button', { className: 'small', textContent: 'Table', style: order.length ? '' : 'visibility:hidden', title: 'all of them in a table, to compare and sort', onclick: () => (location.hash = 'models') }),
-        h('button', { className: 'small', textContent: 'Retry all', title: 'look all of them up in models.dev again', style: order.length ? '' : 'visibility:hidden', onclick: () => lookUp() }),
+        h('button', { className: 'small', textContent: 'Refresh from models.dev', title: 'ask models.dev again what each model can do: context, tools, thinking, images, price', style: order.length ? '' : 'visibility:hidden', onclick: () => lookUp() }),
         h('button', { className: 'small danger', textContent: 'Remove all', title: 'take every model off this list', style: order.length ? '' : 'visibility:hidden', onclick: () => confirm(`Take all ${order.length} model${order.length === 1 ? '' : 's'} off your list? HeartCode then has none to use until you choose one. (They stay under their providers.)`) && saveOrder([], 'all removed: no model chosen now') })),
       h('p', { className: 'sub', style: 'margin:0', textContent: order.length > 1 ? 'HeartCode uses #1. If it fails, it tries #2, then #3… and round again. Drag to change the order.' : order.length ? `HeartCode uses this one. Click more ${side} to add fallbacks: tried, in order, when one fails.` : `The models HeartCode uses, in the order it tries them. Click one ${side} to start.` })),
     order.length ? h('div', { className: 'ohead' }, h('span'), h('span', { textContent: '#' }), h('span', { textContent: 'Model' }), h('span', { textContent: 'Provider' }), h('span', { textContent: 'What it can do' }), h('span')) : null,
@@ -1274,7 +1278,7 @@ function drawMine(s) {
         : order.length > 1 ? 'In your order: HeartCode uses #1, then the next when one fails. Drag a row to move it, or click a column to sort.' : ''),
       SORT.length ? h('button', { className: 'small', textContent: 'Clear sort', onclick: () => setSort([]) }) : null,
       SORT.length ? h('button', { className: 'small primary', textContent: same ? 'This is your order' : 'Use this order', disabled: same, onclick: () => keep(view) }) : null,
-      order.length ? h('button', { className: 'small', textContent: 'Retry all', title: 'look all of them up in models.dev again', onclick: () => lookUp() }) : null,
+      order.length ? h('button', { className: 'small', textContent: 'Refresh from models.dev', title: 'ask models.dev again what each model can do: context, tools, thinking, images, price', onclick: () => lookUp() }) : null,
       order.length ? h('button', { className: 'small', textContent: 'Test all', title: 'send each a short message, several at once (2 per provider at most), to see which really answer', onclick: () => tryAll() }) : null),
     order.length
       ? h('div', { className: 'mt-scroll' }, h('div', { className: 'mt' },
@@ -1350,7 +1354,36 @@ $('v-save').onclick = () => act('/api/voice', { text: $('v-text').value }, 'voic
 const logSwitch = (s, k, title, about) => h('label', { className: 'opt' },
   h('div', { className: 't' }, h('b', { textContent: title }), h('span', { textContent: about })),
   sw({ checked: s.settings[k], 'aria-label': title, onchange: (e) => act('/api/setting', { name: k, value: e.target.checked }, `${title}: ${e.target.checked ? 'on' : 'off'}`) }))
+// How much room the logs take: asked again when the page shows, when it's redrawn, and (at most every
+// few seconds) while requests are being logged.
+const bytes = (n) => (n >= 1e9 ? `${(n / 1e9).toFixed(1)} GB` : n >= 1e6 ? `${(n / 1e6).toFixed(n >= 1e8 ? 0 : 1)} MB` : n >= 1e3 ? `${Math.round(n / 1e3)} kB` : `${n} bytes`)
+let diskAt = 0
+let diskLater = null
+async function drawDisk() {
+  if (Date.now() - diskAt < 3000) return void (diskLater ??= setTimeout(() => ((diskLater = null), drawDisk()), 3000))
+  diskAt = Date.now()
+  try {
+    showDisk(await api('/api/log-size'))
+  } catch {}
+}
+function showDisk(d) {
+  put($('l-disk'),
+    h('div', { className: 'row', style: 'gap:10px;align-items:center' },
+      h('span', {}, h('span', { className: 'k', textContent: 'Logs on disk ' }), h('b', { textContent: bytes(d.total) })),
+      d.total ? h('button', { className: 'small danger', textContent: 'Delete all', title: 'delete every log (the ones being written right now stay)', onclick: clearAll }) : null),
+    h('div', { className: 'k', textContent: `requests ${bytes(d.requests)} · runs ${bytes(d.runs)}` }))
+}
+async function clearAll() {
+  if (!confirm('Delete all logs, of every run and every request? This can\'t be undone. (The ones being written right now stay.)')) return
+  const r = await act('/api/clear-logs', {})
+  if (!r) return
+  showDisk(r.size)
+  diskAt = Date.now()
+  api('/api/requests').then(({ items }) => ((REQS = items), drawReqs()), () => {})
+  toast(`deleted: logs on disk now ${bytes(r.size.total)}`)
+}
 function drawLogging(s) {
+  drawDisk()
   put($('l-run'), logSwitch(s, 'log', 'Keep a log of every run', `From now on: a folder per run in ${s.logs.runs}, a file per tab (tab-1.log, tab-2.log…).`))
   put($('l-req'), logSwitch(s, 'logRequests', 'Log every request and reply', `Right away: a file per request in ${s.logs.requests}, a folder per run.`))
   $('l-detail').value = s.settings.logDetail
@@ -1388,11 +1421,11 @@ const whyOf = (r) => {
   return r.error
 }
 const resultTag = (r) => h('span', { className: `tag ${r.result === 'ok' ? 'ok' : r.result === 'failed' ? 'err' : ''}`, textContent: r.result === 'ok' ? 'ok' : r.result === 'failed' ? `failed${r.status ? ` ${r.status}` : ''}` : 'stopped' })
-const placeTag = (r) => (r.place > 1 ? h('span', { className: 'tag brand', textContent: `#${r.place} of ${r.of} · fallback` }) : r.of > 1 ? h('span', { className: 'tag', textContent: `#1 of ${r.of}` }) : null)
+const placeTag = (r) => (r.place > 1 ? h('span', { className: 'tag brand', textContent: `#${r.place} of ${r.of} · fallback` }) : null) // #1: nothing to say
 function reqRow(r) {
   const key = `${r.run}/${r.file}`
   return h('button', { className: `rq ${r.result}${reqOpen === key ? ' on' : ''}`, 'data-key': key, onclick: () => openReq(r) },
-    h('div', { className: 'l1' }, resultTag(r), h('span', { className: 'm', textContent: r.model }), placeTag(r)),
+    h('div', { className: 'l1' }, resultTag(r), h('span', { className: 'm', textContent: r.model })), // where it is in your list: in its details
     h('div', { className: 'l2' },
       h('span', { textContent: when(r.at) }), h('span', { textContent: r.provider ?? '' }), h('span', { textContent: secs(r.ms) }),
       r.usage ? h('span', { textContent: tokensOf(r.usage) }) : null,
@@ -1597,6 +1630,7 @@ if (token) {
   // a request logged: at the top of the list, nothing else redrawn
   events.addEventListener('request', (e) => {
     const r = JSON.parse(e.data)
+    if (page() === 'logging') drawDisk() // the logs grew
     if (!REQS) return
     REQS.unshift(r)
     if (REQS.length === 1 || !reqShown(r)) return drawReqs()

package/src/settings.js

@@ -17,7 +17,7 @@ import { loadProfile, strategy, profilePath, profileFrom } from './probe.js'
 import { loadPrices, priceOf, limitsOf } from './usage.js'
 import { THEMES, PERMISSIONS } from './ui.js'
 import { loadSkills, frontMatter } from './skills.js'
-import { log, LOGS, REQUESTS, useRequestLog, listRequests, readRequest, pruneLogs, logDays } from './log.js'
+import { log, LOGS, REQUESTS, useRequestLog, listRequests, readRequest, pruneLogs, logDays, logSize, clearLogs } from './log.js'
 
 const PAGE = new URL('./settings.html', import.meta.url)
 const EFFORTS = ['default', 'low', 'medium', 'high']
@@ -189,6 +189,8 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
 
   const routes = {
     '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 }) => {
       name = safeName(name)
       if (!name) throw new Error('a name is needed')

package/src/tools.js

@@ -115,6 +115,22 @@ export function readFileTool(root, p, start, end, maxLines = 400) {
   return numberLines(lines.slice(s - 1, e), s) + more
 }
 
+// An image file: shown to a model that can see images (after the tool results, as MCP screenshots
+// are); for one that can't, where to send it.
+const IMAGE = /\.(png|jpe?g|gif|webp)$/i
+function readImage(s, p) {
+  const abs = resolveIn(s.root, p)
+  const rel = path.relative(s.root, abs) || p
+  if (!fs.existsSync(abs)) return readFileTool(s.root, p)
+  if (s.strat?.vision) {
+    const ext = path.extname(abs).slice(1).toLowerCase()
+    ;(s.pendingImages ??= []).push(`data:image/${ext === 'jpg' ? 'jpeg' : ext};base64,${fs.readFileSync(abs).toString('base64')}`)
+    return `${rel}: the image is attached in the next message`
+  }
+  const seer = s.team?.().find((t) => t.images)
+  return `${rel} is an image, and you can't see images.${seer ? ` Ask a model that can: the agent tool with model "${seer.provider} ${seer.model}", and the image's path in the prompt.` : ''}`
+}
+
 export function searchFiles(root, query, sub = '', limit = 50) {
   const ci = query === query.toLowerCase()
   let re
@@ -468,7 +484,11 @@ export function extraTools(s) {
   }
   // the patch format OpenAI's models are trained on (they also write it as a shell command, below)
   if (/gpt|codex|\bo\d/i.test(s.client?.model ?? '')) out.push({ name: 'apply_patch', description: prompt('agent/tool-apply_patch'), parameters: obj({ input: str }, ['input']) })
-  if (!s.isSub && s.subagent) out.push({ name: 'agent', description: prompt('agent/tool-agent'), parameters: obj({ description: str, prompt: str }, ['description', 'prompt']) })
+  if (!s.isSub && s.subagent) {
+    const team = s.team?.() ?? []
+    const model = { type: 'string', description: prompt('agent/tool-agent-model') }
+    out.push({ name: 'agent', description: prompt('agent/tool-agent'), parameters: obj({ description: str, prompt: str, ...(team.length && { model }) }, ['description', 'prompt']) })
+  }
   return [...out, ...(s.director && !s.appendSystem ? s.director.toolDefs(s) : [])] // manage (director.js); not when a program gives the instructions (--append-system-prompt)
 }
 
@@ -811,7 +831,7 @@ async function tool(name, args, s, signal) {
     }
     switch (name) {
       case 'read_file':
-        return readFileTool(root, args.path, args.start_line, args.end_line)
+        return IMAGE.test(String(args.path ?? '')) ? readImage(s, args.path) : readFileTool(root, args.path, args.start_line, args.end_line)
       case 'list_files': {
         const files = listFiles(root).filter((f) => !args.filter || f.includes(args.filter))
         return files.slice(0, 500).join('\n') + (files.length > 500 ? `\n… ${files.length - 500} more` : '') || 'no files'

package/src/ui.js

@@ -376,6 +376,7 @@ export class UI {
     this.out = output
     this.queue = []
     this.ahead = [] // messages typed (and sent with Enter) while HeartCode was working
+    this.isCommand = (l) => l.startsWith('/') // the app's: only real commands (a path like /Users/… is a message)
     this.keys = { ...DEFAULT_KEYS, ...loadKeys() }
     this.waiters = []
     this.closed = false
@@ -398,7 +399,8 @@ export class UI {
   }
 
   // One model reply: thinking (dim, its own block) kept apart from the answer.
-  response() {
+  // who: the model thinking, named over its thinking (helpers say their own: helperUI in agent.js)
+  response(who) {
     const t0 = Date.now()
     const secs = () => ((Date.now() - t0) / 1000).toFixed(1)
     const write = (x) => this.write(x)
@@ -406,7 +408,7 @@ export class UI {
     let text = null
     let thought = false
     const summary = () => {
-      if (thought && !this.showThinking) this.print(c.faint(c.italic(`✻ thought for ${secs()}s`)))
+      if (thought && !this.showThinking) this.print(c.faint(c.italic(`✻ ${who ? `${who} ` : ''}thought for ${secs()}s`)))
     }
     return {
       think: (t) => {
@@ -415,7 +417,7 @@ export class UI {
         if (!this.showThinking) return this.spinner(`thinking · ${secs()}s`)
         if (!think) {
           this.gap()
-          this.print(c.faint(c.italic('✻ Thinking…')))
+          this.print(c.faint(c.italic(`✻ ${who ? `${who} is thinking` : 'Thinking'}…`)))
           think = new Block(write, { style: (x) => c.think(c.italic(x)) })
         }
         think.push(t)
@@ -704,7 +706,13 @@ export class UI {
         m.off = rl.line
         return this.refreshMenu()
       }
-      if (m.on && key.name === 'tab') return it && this.#accept(it)
+      // Tab only completes the text: the menu closes (no list of a command's choices pops up); Enter runs it
+      if (m.on && key.name === 'tab') {
+        if (!it) return
+        this.#accept(it)
+        m.off = rl.line
+        return this.refreshMenu()
+      }
       if (it && key.name === 'return' && rl.line.slice(it.start, it.end) !== it.value) {
         this.#accept(it)
         if (it.insertOnly) return
@@ -736,7 +744,7 @@ export class UI {
       if (/^\/btw\b/.test(line) && this.onBtw) this.onBtw(line.replace(/^\/btw\b/, '').trim()) // answered now, beside the task
       else if (line) {
         this.ahead.push(line)
-        this.print(`${c.faint(' ↳')} ${c.muted(line.split('\n')[0])} ${c.faint(/^\//.test(line) ? '(runs when this is done)' : '(goes to the model at its next step, or runs next)')}`)
+        this.print(`${c.faint(' ↳')} ${c.muted(line.split('\n')[0])} ${c.faint(this.isCommand(line) ? '(runs when this is done)' : '(goes to the model at its next step, or runs next)')}`)
       }
       return this.render()
     }
@@ -841,8 +849,8 @@ export class UI {
 
   // Messages typed while working that can go to the running task now (not commands); taken.
   takeAhead() {
-    const out = this.ahead.filter((l) => !l.startsWith('/'))
-    this.ahead = this.ahead.filter((l) => l.startsWith('/'))
+    const out = this.ahead.filter((l) => !this.isCommand(l))
+    this.ahead = this.ahead.filter((l) => this.isCommand(l))
     return out
   }