heartcode 0.1.14 → 0.1.24

package/src/settings.js

@@ -21,7 +21,7 @@ import { log, LOGS, REQUESTS, useRequestLog, listRequests, readRequest, pruneLog
 
 const PAGE = new URL('./settings.html', import.meta.url)
 const EFFORTS = ['default', 'low', 'medium', 'high']
-const TOGGLES = { autoCompact: 'compact the conversation when the context is 70% full', director: 'let the model add skills, MCP servers and change settings when asked', format: "run the project's formatter on every file HeartCode writes", lsp: "show the model a language server's errors after each edit" }
+const TOGGLES = { autoCompact: 'compact the conversation when it fills 85% of the model\'s context window', director: 'let the model add skills, MCP servers and change settings when asked', format: "run the project's formatter on every file HeartCode writes", lsp: "show the model a language server's errors after each edit" }
 // The Logging page's: both off unless switched on; how much of each request ("full" or "summary")
 const LOG_SWITCHES = ['log', 'logRequests']
 const DETAILS = ['full', 'summary']
@@ -102,10 +102,11 @@ const skillsDir = () => path.join(HOME, 'skills')
 // what the provider said (names, sizes, prices; not what's known from models.dev or tests, which
 // changes). Asked for again when its list is switched on or off, or the provider is changed.
 const LISTS = path.join(HOME, 'model-lists.json')
+const LIST_V = 2 // how a saved list was read (2: airforce's cents, Cloudflare's prices); another: read again
 // The page's own choices (sorts, folded providers, the provider ranking): kept here, not in the
 // browser, whose storage is per address (a new port each time)
 const PREFS = path.join(HOME, 'settings-page.json')
-const PREF_KEYS = ['catSort', 'folded', 'sort', 'rank']
+const PREF_KEYS = ['catSort', 'freeOnly', 'folded', 'sort', 'rank']
 function forgetList(...names) {
   const all = readJson(LISTS, {})
   if (!names.some((n) => n in all)) return
@@ -332,7 +333,7 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
   const state = () => ({
     providers: Object.entries(byName(cfg.providers))
       .filter(([n]) => n !== cfg.adhoc)
-      .map(([name, p]) => ({ name, baseUrl: p.baseUrl, key: mask(p.apiKey), list: p.list !== false, added: p.models ?? [] })),
+      .map(([name, p]) => ({ name, baseUrl: p.baseUrl, key: mask(p.apiKey), list: p.list !== false, off: p.off === true, added: p.models ?? [] })),
     provider: cfg.provider ?? null,
     model: cfg.model ?? null,
     order: [...(cfg.providers[cfg.provider] && cfg.model ? [{ provider: cfg.provider, model: cfg.model }] : []), ...rotationOf(cfg).then].map((t) => ({ ...t, tested: testedOf(t), known: knownOf(t), price: priceFor(t) })),
@@ -414,6 +415,15 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
       save('provider')
       return state()
     },
+    // A provider switched off: kept (its key, its models in your list), but HeartCode skips its models
+    // until it's on again.
+    'POST /api/provider/on': ({ name, on }) => {
+      if (!cfg.providers[name]) throw new Error(`no provider "${name}"`)
+      if (on) delete cfg.providers[name].off
+      else cfg.providers[name].off = true
+      save('provider')
+      return state()
+    },
     // A model added by its name (one the provider doesn't list, or its list is off): remembered.
     // all: every model added by name forgotten at once
     'POST /api/provider/added': ({ name, model, remove, all }) => {
@@ -437,11 +447,11 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
       if (!p) throw new Error(`no provider "${name}"`)
       if (p.list === false) return { models: [], details: {}, off: true }
       const lists = readJson(LISTS, {})
-      let saved = lists[name]?.baseUrl === p.baseUrl && lists[name].models?.length ? lists[name] : null // an empty one: asked again
+      let saved = lists[name]?.baseUrl === p.baseUrl && lists[name].models?.length && lists[name].v === LIST_V ? lists[name] : null // an empty one, or one read the old way: asked again
       if (!saved) {
         const entries = await new Client({ baseUrl: p.baseUrl, apiKey: p.apiKey }).modelEntries()
         const num = (...xs) => xs.map(Number).find((x) => x > 0)
-        saved = { baseUrl: p.baseUrl, at: Date.now(), models: entries.map((m) => String(m.id ?? m.name)), details: Object.fromEntries(entries.map((m) => [String(m.id ?? m.name), {
+        saved = { v: LIST_V, baseUrl: p.baseUrl, at: Date.now(), models: entries.map((m) => String(m.id ?? m.name)), details: Object.fromEntries(entries.map((m) => [String(m.id ?? m.name), {
           name: m.name && m.name !== String(m.id ?? m.name) ? String(m.name) : undefined,
           context: num(m.context_length, m.context_window, m.max_model_len, m.max_context_length, m.top_provider?.context_length),
           owner: m.owned_by && m.owned_by !== 'system' ? String(m.owned_by) : undefined,
@@ -505,6 +515,28 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
     // itself). In the requests log as a model test. Never throws: { ok, ms, reply } or { ok: false, error }.
     'POST /api/try': ({ provider, model } = {}) => testOne({ provider, model: String(model ?? '') }),
     // the tests' results, and the run going now (with the models it hasn't tested yet)
+    // Test, on a model's row: one "Hello" to it, and exactly what was sent and what came back (the
+    // key masked), for the page to show. Not streamed, so the answer is the provider's own JSON.
+    'POST /api/hello': async ({ provider, model }) => {
+      const c = clientFor({ provider, model })
+      if (!c || !model) throw new Error(`no provider "${provider}"`)
+      const url = `${c.baseUrl}/chat/completions`
+      const body = { model, messages: [{ role: 'user', content: 'Hello' }] }
+      const sent = { method: 'POST', url, headers: { 'content-type': 'application/json', ...(c.apiKey && { authorization: `Bearer ${mask(c.apiKey)}` }) }, body }
+      const t0 = Date.now()
+      try {
+        const res = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', ...(c.apiKey && { authorization: `Bearer ${c.apiKey}` }) }, body: JSON.stringify(body), signal: AbortSignal.timeout(90_000) })
+        const text = await res.text()
+        let json = null
+        try {
+          json = JSON.parse(text)
+        } catch {}
+        const reply = json?.choices?.[0]?.message?.content ?? null
+        return { sent, received: { status: res.status, ok: res.ok, ms: Date.now() - t0, type: res.headers.get('content-type'), body: json ?? text.slice(0, 20_000) }, reply }
+      } catch (e) {
+        return { sent, received: { error: e.name === 'TimeoutError' ? 'no answer within 90 seconds' : `couldn't send it: ${e.cause?.code || e.cause?.message || e.message}`, ms: Date.now() - t0 } }
+      }
+    },
     'POST /api/tests': () => ({ results: tests, run: run && { ...runState(), pending: [...run.pending] } }),
     // a run: all your models, or the ones given (only); one at a time if one is going already
     'POST /api/tests/start': ({ only } = {}) => {
@@ -772,7 +804,11 @@ export function startSettings({ cfg, apply = () => {}, port = 0 } = {}) {
 // output } (either may be missing), or undefined. Not models.dev's: the same model costs differently
 // at different providers. The forms lists use: pricing.prompt/completion (per token, OpenRouter's);
 // pricing.input/output with a unit (per million when it says so; no unit: per token when it's that
-// small); input_price/output_price (per token); pricepermilliontokens; only a free tier.
+// small); input_price/output_price (per token); pricepermilliontokens (in cents: api.airforce's 88
+// is its own 880000 micro-dollars); Cloudflare's properties ("per M input tokens"); only a free
+// tier (is_free, or a tier named free when nothing else is said: a list's "free tier" with a price
+// is a plan that may use it, not a model that costs nothing).
+const cfPrice = (m, unit) => (Array.isArray(m.properties) ? m.properties.find((p) => p?.property_id === 'price')?.value?.find?.((v) => unit.test(v?.unit ?? ''))?.price : undefined)
 export function listedPrice(m) {
   const num = (x) => (x === null || x === undefined || x === '' || !(Number(x) >= 0) ? undefined : Number(x)) // -1: varies (a router's "auto")
   const pr = m.pricing && typeof m.pricing === 'object' && !Array.isArray(m.pricing) ? m.pricing : {}
@@ -781,7 +817,8 @@ export function listedPrice(m) {
     [num(pr.prompt), num(pr.completion), () => 1e6],
     [num(pr.input), num(pr.output), unit],
     [num(m.input_price), num(m.output_price), () => 1e6],
-    [num(m.pricepermilliontokens), num(m.output_pricepermilliontokens), () => 1],
+    [num(m.pricepermilliontokens), num(m.output_pricepermilliontokens), () => 0.01],
+    [num(cfPrice(m, /^per M input tokens$/i)), num(cfPrice(m, /^per M output tokens$/i)), () => 1],
   ]) {
     if (i === undefined && o === undefined) continue
     const per = (x) => (x === undefined ? undefined : Number((x * k(x)).toPrecision(6)))

package/src/skills.js

@@ -18,7 +18,26 @@ export const USES = ['me', 'model', 'both']
 
 export function frontMatter(text) {
   const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text)
-  const meta = Object.fromEntries((m?.[1] ?? '').split('\n').map((l) => /^([\w-]+):\s*(.*)$/.exec(l.trim())).filter(Boolean).map(([, k, v]) => [k, v.replace(/^["']|["']$/g, '')]))
+  const lines = (m?.[1] ?? '').replace(/\r/g, '').split('\n')
+  const meta = {}
+  const indent = (l) => l.length - l.trimStart().length
+  for (let i = 0; i < lines.length; i++) {
+    const key = /^([\w-]+):\s*(.*)$/.exec(lines[i])
+    if (!key) continue
+    const [, k, raw] = key
+    const base = indent(lines[i])
+    const block = /^([|>])([+-]?)\s*$/.exec(raw) // a YAML block scalar: | literal, > folded (Claude Code, others use "description: >-")
+    if (block) {
+      const kept = []
+      while (i + 1 < lines.length && (lines[i + 1].trim() === '' || indent(lines[i + 1]) > base)) kept.push(lines[++i])
+      const minIndent = Math.min(...kept.filter((l) => l.trim()).map(indent), Infinity)
+      let v = kept.map((l) => l.slice(Number.isFinite(minIndent) ? minIndent : 0)).join(block[1] === '>' ? ' ' : '\n')
+      if (block[2] !== '+') v = v.replace(/\n+$/, '') // "-" strips trailing newlines; default keeps one at most
+      meta[k] = v.trim()
+    } else {
+      meta[k] = raw.replace(/^["']|["']$/g, '')
+    }
+  }
   return { meta, body: (m ? m[2] : text).trim() }
 }
 

package/src/tabs.js

@@ -42,7 +42,7 @@ export class Tabs {
     tab.output = Object.assign(new EventEmitter(), { isTTY: true, write: (s) => (on() ? real.output.write(s) : true) })
     for (const k of ['columns', 'rows']) Object.defineProperty(tab.output, k, { get: () => real.output[k] })
     Object.defineProperty(tab.output, 'hidden', { get: () => !on() })
-    tab.hooks = { tabBar: (cols) => this.bar(cols), onTab: (what) => this.key(what) }
+    tab.hooks = { tabBar: (cols) => this.bar(cols), onTab: (what) => this.key(what), onTabClick: (col) => this.click(col) }
     this.list.push(tab)
     this.at = tab
     tab.id = this.made = (this.made ?? 0) + 1 // for its log file: tab-1.log… (its place in the bar can change)
@@ -96,6 +96,13 @@ export class Tabs {
     if (n) this.show(this.list[Number(n) - 1])
   }
 
+  // a click on the tab bar (a 0-based column): that tab
+  click(col) {
+    if (this.locked) return
+    const hit = this.spans?.find((s) => col >= s.from && col < s.to)
+    if (hit && hit.tab !== this.at) this.show(hit.tab)
+  }
+
   // working, waiting for an answer, or done since you last looked at it
   state(t) {
     const ui = t.ui
@@ -108,40 +115,48 @@ export class Tabs {
   // The tab bar, three rows: tabs drawn as tabs, the one on screen open onto it (its bottom
   // edge missing), the others closed off. Number, name, and what it's doing.
   //  ╭─────────────╮ ╭──────────────╮
-  //  │ 1 heart_cli │ │ 2 fix tests ●│  + Ctrl+T new tab
+  //  │ 1 heart_cli │ │ 2 fix tests ●│  Ctrl+T open a new tab
   // ─╯             ╰─┴──────────────┴──────────────────
   bar(cols = 100) {
     const mark = { '?': c.warn('?'), '●': c.brand('●'), '✓': c.ok('✓') }
     const room = Math.max(6, Math.floor((cols - 24) / this.list.length) - 7) // a name's cells, so they all fit
     let [top, mid, bottom] = [' ', ' ', c.ghost('─')]
+    let col = 1
+    this.spans = [] // the columns each tab takes, for a click (click)
     this.list.forEach((t, i) => {
       const on = t === this.at
       const s = this.state(t)
-      const name = cut(t.name || t.app?.chat?.title || pathTail(t.app?.root), room)
+      const name = cut(t.name || t.app?.chat?.title || pathTail(t.app?.root), Math.min(NAME_MAX, room))
       const text = ` ${i + 1} ${name}${s ? ' ' + s : ''} `
       const w = width(text)
       const line = on ? c.brand : c.ghost
       const label = ` ${on ? c.bright(c.bold(`${i + 1} ${name}`)) : c.muted(`${i + 1} ${name}`)}${s ? ' ' + mark[s] : ''} `
+      this.spans.push({ from: col, to: col + w + 2, tab: t })
+      col += w + 3
       top += line(`╭${'─'.repeat(w)}╮`) + ' '
       mid += line('│') + label + line('│') + ' '
       bottom += (on ? c.brand(`╯${' '.repeat(w)}╰`) : c.ghost(`┴${'─'.repeat(w)}┴`)) + c.ghost('─')
     })
-    const hint = this.list.length > 1 ? 'Ctrl+T new · Ctrl+Q close · Ctrl+N/P switch' : 'Ctrl+T new tab'
+    const hint = this.list.length > 1 ? 'Ctrl+T open a tab · Ctrl+Q close this one · Ctrl+N/P switch tabs' : 'Ctrl+T open a new tab'
     mid += ` ${c.faint(hint)}`
     bottom += c.ghost('─'.repeat(Math.max(0, cols - width(bottom.replace(/\x1b\[[0-9;]*m/g, '')))))
     return [top, mid, bottom]
   }
 }
 
-// At most n cells, with … when cut.
+// A tab's name: at most 20 cells, "..." included (fewer when many tabs share a narrow screen).
+const NAME_MAX = 20
+
+// At most n cells, ending in "..." when cut.
 function cut(s, n) {
+  s = String(s ?? '').replace(/\s+/g, ' ').trim()
   if (width(s) <= n) return s
   let out = ''
   for (const ch of s) {
-    if (width(out + ch) > n - 1) break
+    if (width(out + ch) > n - 3) break
     out += ch
   }
-  return out + '…'
+  return out.trimEnd() + '...'
 }
 
 const pathTail = (p = '') => p.split(/[\\/]/).filter(Boolean).pop() ?? p

package/src/tools.js

@@ -15,7 +15,7 @@ import { webFetch, webSearch } from './web.js'
 import { runHooks } from './hooks.js'
 import { parsePatch, applyChunks } from './patch.js'
 import { formatFile } from './format.js'
-import { diagnose } from './lsp.js'
+import { diagnose, lspTool, findCommand } from './lsp.js'
 
 const IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', '.next', 'coverage', '.venv', 'venv', '__pycache__', 'target', '.cache', '.DS_Store'])
 
@@ -42,15 +42,28 @@ export function saveOutput(chatId, name, data, ext = 'txt') {
 export function resolveIn(root, p) {
   const clean = String(p ?? '').trim().replace(/^["'`]+|["'`]+$/g, '')
   if (!clean) throw new Error('no path given')
-  let abs = path.resolve(root, clean)
+  const bare = root.replace(/^[\\/]+/, '') // the project's own path, its leading "/" left out by a sloppy copy
+  let abs = clean === bare || clean.startsWith(bare + '/') ? path.join(root, clean.slice(bare.length)) : path.resolve(root, clean)
   if (abs.startsWith(OUTPUTS + path.sep)) return abs // a saved tool output
   // "num.js:" or "num.js," from a sloppy model: the file without the stray mark, if that one exists
   const trimmed = path.resolve(root, clean.replace(/[:;,.]+$/, ''))
   if (trimmed !== abs && !fs.existsSync(abs) && fs.existsSync(trimmed)) abs = trimmed
-  if (abs !== root && !abs.startsWith(root + path.sep)) throw new Error(`${clean} is outside the project; use a path relative to the project folder`)
+  if (abs !== root && !abs.startsWith(root + path.sep)) abs = intoProject(root, clean) ?? abs
+  if (abs !== root && !abs.startsWith(root + path.sep)) throw new Error(`${clean} is outside the project; use a path relative to the project folder (${root}), like "index.html" or "src/app.js"`)
   return abs
 }
 
+// A small model's mangled copy of the project's long path, meant inside it: any path with the
+// project folder's name in it ("/Users-me-…/myapp/index.html"): what comes after that name.
+// null: no such reading.
+function intoProject(root, p) {
+  const slash = p.replace(/\\/g, '/')
+  const name = path.basename(root)
+  const parts = slash.split('/')
+  const at = parts.lastIndexOf(name)
+  return at >= 0 ? path.resolve(root, parts.slice(at + 1).join('/') || '.') : null
+}
+
 // Project files a message names: by its path, or by a file name only one file in the project has
 // ("num.js"; in a project with three index.js, "index.js" names none of them).
 export function namedFiles(text, files) {
@@ -99,6 +112,33 @@ export function listFiles(root, limit = 2000) {
   return files.sort()
 }
 
+// One folder's entries (the project root: ''), all of them: folders end in "/", what .gitignore
+// leaves out says "(ignored)". Names only. At most `limit`.
+export function folderView(root, rel = '', limit = 200) {
+  const abs = resolveIn(root, rel || '.')
+  let entries
+  try {
+    entries = fs.readdirSync(abs, { withFileTypes: true })
+  } catch (e) {
+    return { error: e.code === 'ENOENT' ? `no folder ${rel}` : e.code === 'ENOTDIR' ? `${rel} is a file, not a folder` : e.message }
+  }
+  let ignored = null // the entries .gitignore leaves out ("node_modules/", "dist/", ".env")
+  try {
+    const out = execFileSync('git', ['ls-files', '-z', '--others', '--ignored', '--exclude-standard', '--directory', '--', abs], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 16 << 20 })
+    ignored = new Set(out.split('\0').filter(Boolean).map((f) => f.replace(/\/$/, '')))
+  } catch {}
+  const here = path.relative(root, abs)
+  const names = entries
+    .map((e) => ({ name: e.name, dir: e.isDirectory() || (e.isSymbolicLink() && fs.statSync(path.join(abs, e.name), { throwIfNoEntry: false })?.isDirectory()) }))
+    .sort((a, b) => b.dir - a.dir || a.name.localeCompare(b.name))
+  const shown = names.slice(0, limit).map(({ name, dir }) => {
+    const p = path.join(here, name).split(path.sep).join('/')
+    const off = ignored ? ignored.has(p) : IGNORE.has(name)
+    return `${name}${dir ? '/' : ''}${off && name !== '.git' ? ' (ignored)' : ''}`
+  })
+  return { entries: shown, more: Math.max(0, names.length - limit) }
+}
+
 const isBinary = (buf) => buf.subarray(0, 8000).includes(0)
 export const numberLines = (lines, from = 1) => lines.map((l, i) => `${from + i}| ${l}`).join('\n')
 
@@ -285,6 +325,7 @@ export async function proposeWrite(s, rel, old, next) {
   else {
     fs.mkdirSync(path.dirname(abs), { recursive: true })
     fs.writeFileSync(abs, next)
+    if (/\.(html?|css)$/i.test(rel)) (s.uiTouched ??= new Set()).add(rel) // looked at in a browser when the model says it's done (agent.js)
   }
   const add = ops.filter(([t]) => t === '+').length
   const del = ops.filter(([t]) => t === '-').length
@@ -441,7 +482,9 @@ const obj = (properties, required = []) => ({ type: 'object', properties, requir
 export const TOOL_DEFS = [
   { name: 'read_file', description: prompt('agent/tool-read_file'), parameters: obj({ path: str, start_line: int, end_line: int }, ['path']) },
   { name: 'search', description: prompt('agent/tool-search'), parameters: obj({ query: str, path: str }, ['query']) },
-  { name: 'list_files', description: prompt('agent/tool-list_files'), parameters: obj({ filter: str }) },
+  { name: 'list_files', description: prompt('agent/tool-list_files'), parameters: obj({ path: str, filter: str }) },
+  { name: 'find_command', description: prompt('agent/tool-find_command'), parameters: obj({ names: { type: 'array', items: str } }, ['names']) },
+  { name: 'lsp', description: prompt('agent/tool-lsp'), parameters: obj({ server: str, language: str, action: { type: 'string', enum: ['definition', 'references', 'hover', 'errors'] }, file: str, line: int, column: int, name: str }, ['server', 'language', 'action', 'file']) },
   // One edit per call: a list of edits per call measured 2–6 malformed calls per benchmark run vs 0.
   { name: 'edit_file', description: prompt('agent/tool-edit_file'), parameters: obj({ path: str, search: str, replace: str }, ['path', 'search', 'replace']) },
   { name: 'write_file', description: prompt('agent/tool-write_file'), parameters: obj({ path: str, content: str, append: { type: 'boolean' } }, ['path', 'content']) },
@@ -455,7 +498,15 @@ export const TOOL_DEFS = [
 // Plan mode (permission "plan"): looking around is fine, changing things isn't. Edits are refused,
 // and a command runs only when it only reads (else it's refused, not asked about).
 export const PLAN_HIDDEN = new Set(['edit_file', 'write_file', 'apply_patch'])
-const READ_ONLY = /^(ls|cat|head|tail|wc|grep|egrep|rg|find|fd|tree|pwd|file|stat|du|df|which|type|echo|date|printenv|diff|cmp|sort|uniq|cut|jq|nl|basename|dirname|realpath|readlink|uname|whoami|(node|npm|python3?|go|cargo) --version|npm (ls|list|view|outdated)|git (status|log|diff|show|ls-files|blame|grep|describe|shortlog|rev-parse|config --get)|git (branch|tag|remote)( -[avlr]+| --list| -v)*$)\b/
+const READ_ONLY = /^(cd|ls|cat|head|tail|wc|grep|egrep|rg|find|fd|tree|pwd|file|stat|du|df|which|type|echo|date|printenv|diff|cmp|sort|uniq|cut|jq|nl|basename|dirname|realpath|readlink|uname|whoami|(node|npm|python3?|go|cargo) --version|npm (ls|list|view|outdated)|git (status|log|diff|show|ls-files|blame|grep|describe|shortlog|rev-parse|config --get)|git (branch|tag|remote)( -[avlr]+| --list| -v)*$)\b/
+// A command that went into a folder outside the project (a small model copying the project's long
+// path wrong, then lost in what it finds there): told where the project is.
+function outsideNote(root, cmd) {
+  const dirs = [...cmd.matchAll(/(?:^|&&|;|\|\|)\s*cd\s+("[^"]+"|'[^']+'|\S+)/g)].map((m) => m[1].replace(/^["']|["']$/g, '').replace(/^~(?=\/|$)/, os.homedir()))
+  const out = dirs.map((d) => path.resolve(root, d)).find((d) => d !== root && !d.startsWith(root + path.sep))
+  return out ? `\n\n${prompt('agent/outside-project', { dir: out, root })}` : ''
+}
+
 export function readOnlyCommand(cmd) {
   const c = String(cmd).trim()
   if (/[>`]|\$\(|\b(sudo|rm|mv|cp|tee|chmod|chown|dd|truncate|mkdir|touch|ln)\b|-delete\b|-exec|-ok\b|sed\s+-i|\bsort\b.*\s-o/.test(c)) return false // writes, or runs something else
@@ -940,11 +991,22 @@ async function tool(name, args, s, signal, id) {
       case 'read_file':
         return IMAGE.test(String(args.path ?? '')) ? readImage(s, args.path) : readFileTool(root, args.path, args.start_line, args.end_line)
       case 'list_files': {
+        if (args.path !== undefined && args.path !== '' && !args.filter) {
+          const v = folderView(root, String(args.path))
+          return v.error ? `error: ${v.error}` : v.entries.join('\n') + (v.more ? `\n… ${v.more} more` : '') || '(empty folder)'
+        }
         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'
       }
       case 'search':
         return searchFiles(root, String(args.query ?? ''), args.path)
+      case 'find_command': {
+        const names = (Array.isArray(args.names) ? args.names : String(args.names ?? args.name ?? '').split(/[\s,]+/)).map(String).filter(Boolean)
+        if (!names.length) return 'error: find_command needs "names": the commands to look for, like ["rg", "pnpm"]'
+        return names.map((n) => `${n}: ${findCommand(root, n) ?? 'not installed'}`).join('\n')
+      }
+      case 'lsp':
+        return await lspTool(s, args, signal)
       case 'edit_file':
         return await editFiles(s, args)
       case 'write_file':
@@ -963,7 +1025,7 @@ async function tool(name, args, s, signal, id) {
       }
       case 'run_command':
         if (/^\s*apply_patch\b[\s\S]*\*\*\* Begin Patch/.test(String(args.command ?? ''))) return await applyPatch(s, args.command) // apply_patch <<'EOF' … as Codex runs it
-        return await runConfirmed(s, String(args.command ?? ''), signal)
+        return (await runConfirmed(s, String(args.command ?? ''), signal)) + outsideNote(root, String(args.command ?? ''))
       case 'apply_patch':
         return await applyPatch(s, args.input ?? args.patch ?? args.command ?? '')
       case 'mcp':