thincoder 0.9.0 → 0.11.0

package/src/tools/lsp.mjs

@@ -0,0 +1,317 @@
+/**
+ * tools/lsp.mjs — LSP (Language Server Protocol) code intelligence tool
+ * Zero-dependency JSON-RPC 2.0 over stdio client.
+ *
+ * Provides: go-to-definition, find-references, hover info, document symbols, diagnostics.
+ * Lazy-starts language servers on first call. Configurable via config.json lsp.servers.
+ *
+ * Config format:
+ *   "lsp": {
+ *     "servers": {
+ *       "typescript": { "command": "typescript-language-server", "args": ["--stdio"] },
+ *       "python": { "command": "pyright-langserver", "args": ["--stdio"] }
+ *     }
+ *   }
+ */
+
+import { spawn } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { join, extname } from "node:path"
+
+// ---- JSON-RPC transport over stdio ----
+
+/** Send a JSON-RPC request to the server via stdin */
+function send(proc, message) {
+  const body = JSON.stringify(message)
+  const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`
+  proc.stdin.write(header + body)
+}
+
+/** Read one JSON-RPC message from stdout. Returns parsed JSON, or null on EOF. */
+function readMessage(proc) {
+  return new Promise((resolve) => {
+    let header = ""
+    let contentLength = -1
+
+    const onData = (chunk) => {
+      if (contentLength < 0) {
+        header += chunk.toString()
+        const match = header.match(/Content-Length: (\d+)\r\n\r\n/)
+        if (match) {
+          contentLength = parseInt(match[1])
+          const bodyStart = header.indexOf("\r\n\r\n") + 4
+          const remaining = header.slice(bodyStart)
+          header = ""
+          if (remaining.length >= contentLength) {
+            proc.stdout.removeListener("data", onData)
+            try { resolve(JSON.parse(remaining.slice(0, contentLength))) } catch { resolve(null) }
+            return
+          }
+          // Need more data — leave remaining in a buffer-like state
+          proc.stdout.removeListener("data", onData)
+          readBody(proc, remaining, contentLength).then(resolve)
+        }
+      }
+    }
+
+    proc.stdout.on("data", onData)
+  })
+}
+
+function readBody(proc, buf, targetLen) {
+  return new Promise((resolve) => {
+    const onData = (chunk) => {
+      buf += chunk.toString()
+      if (buf.length >= targetLen) {
+        proc.stdout.removeListener("data", onData)
+        try { resolve(JSON.parse(buf.slice(0, targetLen))) } catch { resolve(null) }
+      }
+    }
+    proc.stdout.on("data", onData)
+  })
+}
+
+/** Send a request and wait for the matching response */
+async function request(proc, method, params, id) {
+  send(proc, { jsonrpc: "2.0", id, method, params })
+  while (true) {
+    const msg = await readMessage(proc)
+    if (!msg) return null
+    if (msg.id === id) return msg
+    // Store notifications for later retrieval (diagnostics)
+    if (msg.method === "textDocument/publishDiagnostics") {
+      proc._diagnostics = proc._diagnostics || {}
+      proc._diagnostics[msg.params.uri] = msg.params.diagnostics
+    }
+  }
+}
+
+/** Send a notification (no response expected) */
+function notify(proc, method, params) {
+  send(proc, { jsonrpc: "2.0", method, params })
+}
+
+// ---- Language server process management ----
+
+const servers = new Map() // ext → { proc, rootUri, ready }
+
+/** Convert file path to file:// URI */
+function toUri(absPath) {
+  return "file:///" + absPath.replace(/\\/g, "/").replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + "%3A")
+}
+
+/** Resolve which language server to use for a file extension */
+function resolveServerConfig(config, ext) {
+  const map = {
+    ".js": "typescript", ".mjs": "typescript", ".cjs": "typescript",
+    ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript",
+    ".py": "python", ".pyi": "python",
+    ".rs": "rust",
+    ".go": "go",
+  }
+  const key = map[ext] || ext.slice(1)
+  const servers = config?.lsp?.servers ?? {}
+  return servers[key] || null
+}
+
+/** Start or reuse a language server for the given file */
+async function getServer(cwd, filePath, config) {
+  const ext = extname(filePath).toLowerCase()
+  const srvConfig = resolveServerConfig(config, ext)
+  if (!srvConfig) return null
+
+  const abs = join(cwd, ...filePath.split("/"))
+  if (!existsSync(abs)) return null
+
+  const rootUri = toUri(cwd)
+  const key = `${ext}:${cwd}`
+  let entry = servers.get(key)
+
+  if (entry && entry.ready) return entry
+
+  // Start new server
+  const proc = spawn(srvConfig.command, srvConfig.args || [], {
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  })
+
+  proc.stderr.on("data", () => {}) // suppress stderr noise
+
+  entry = { proc, rootUri, ready: false }
+  servers.set(key, entry)
+
+  // Initialize handshake
+  const initResult = await request(proc, "initialize", {
+    processId: null,
+    rootUri,
+    capabilities: {
+      textDocument: {
+        definition: { linkSupport: false },
+        references: {},
+        hover: { contentFormat: ["plaintext"] },
+        documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+      },
+    },
+    workspace: {},
+  }, 1)
+
+  if (!initResult) {
+    proc.kill()
+    servers.delete(key)
+    return null
+  }
+
+  notify(proc, "initialized", {})
+  entry.ready = true
+  return entry
+}
+
+/** Notify the server that a file is open (required before queries) */
+async function ensureOpen(proc, uri, ext) {
+  const langMap = { ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".ts": "typescript", ".tsx": "typescript", ".mts": "typescript", ".cts": "typescript", ".py": "python", ".rs": "rust", ".go": "go" }
+  const languageId = langMap[ext] || ext.slice(1)
+  notify(proc, "textDocument/didOpen", {
+    textDocument: {
+      uri,
+      languageId,
+      version: 1,
+      text: readFileSync(uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":").replace(/\//g, "\\"), "utf8"),
+    },
+  })
+}
+
+// ---- Tool definition ----
+
+export const lspTool = {
+  name: "lsp",
+  description:
+    "LSP code intelligence: go to definition, find references, hover info, document symbols, diagnostics. " +
+    "Use this to understand code structure without grep-guessing function locations or type shapes.",
+  parameters: {
+    type: "object",
+    properties: {
+      subcommand: {
+        type: "string",
+        enum: ["definition", "references", "hover", "symbols", "diagnostics"],
+        description: "LSP operation to perform",
+      },
+      uri: {
+        type: "string",
+        description: "Target file path (relative to project root)",
+      },
+      line: {
+        type: "integer",
+        description: "1-based line number (for definition/references/hover)",
+      },
+      character: {
+        type: "integer",
+        description: "1-based character offset (for definition/references/hover)",
+      },
+    },
+    required: ["subcommand", "uri"],
+  },
+  readonly: true,
+
+  async execute(args, ctx) {
+    const config = ctx.agent?.config ?? {}
+    const cwd = ctx.cwd
+    const filePath = args.uri
+
+    try {
+      const entry = await getServer(cwd, filePath, config)
+      if (!entry) {
+        const ext = extname(filePath).toLowerCase()
+        return `No LSP server configured for "${ext}" files. Add one to config.json:\n"lsp": { "servers": { "${ext.slice(1)}": { "command": "...", "args": ["--stdio"] } } }`
+      }
+
+      const { proc } = entry
+      const abs = join(cwd, ...filePath.split("/"))
+      const uri = toUri(abs)
+      const ext = extname(filePath).toLowerCase()
+      await ensureOpen(proc, uri, ext)
+
+      // Wait briefly for diagnostics to arrive
+      await new Promise((r) => setTimeout(r, 300))
+
+      switch (args.subcommand) {
+        case "definition": {
+          if (!args.line || !args.character) return "Error: line and character required for definition"
+          const res = await request(proc, "textDocument/definition", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+          }, 10)
+          if (!res?.result) return "No definition found."
+          const locs = Array.isArray(res.result) ? res.result : [res.result]
+          return locs.map((l) => {
+            const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
+            return `${path}:${l.range.start.line + 1}:${l.range.start.character + 1}`
+          }).join("\n")
+        }
+
+        case "references": {
+          if (!args.line || !args.character) return "Error: line and character required for references"
+          const res = await request(proc, "textDocument/references", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+            context: { includeDeclaration: false },
+          }, 10)
+          if (!res?.result?.length) return "No references found."
+          return res.result.slice(0, 50).map((l) => {
+            const path = l.uri.replace(/^file:\/\/\//, "").replace(/%3A/, ":")
+            return `${path}:${l.range.start.line + 1}:${l.range.start.character + 1}`
+          }).join("\n") + (res.result.length > 50 ? `\n... and ${res.result.length - 50} more` : "")
+        }
+
+        case "hover": {
+          if (!args.line || !args.character) return "Error: line and character required for hover"
+          const res = await request(proc, "textDocument/hover", {
+            textDocument: { uri },
+            position: { line: args.line - 1, character: args.character - 1 },
+          }, 10)
+          if (!res?.result?.contents) return "No hover info available."
+          const contents = res.result.contents
+          if (typeof contents === "string") return contents
+          if (Array.isArray(contents)) return contents.map((c) => typeof c === "string" ? c : c.value).join("\n")
+          if (contents.value) return contents.value
+          return JSON.stringify(contents)
+        }
+
+        case "symbols": {
+          const res = await request(proc, "textDocument/documentSymbol", {
+            textDocument: { uri },
+          }, 10)
+          if (!res?.result?.length) return "No symbols found."
+          function render(nodes, depth) {
+            const lines = []
+            for (const n of nodes) {
+              const kind = n.kind != null ? ` [${symbolKind(n.kind)}]` : ""
+              lines.push(`${"  ".repeat(depth)}${n.name}${kind} — L${n.range.start.line + 1}`)
+              if (n.children?.length) lines.push(...render(n.children, depth + 1))
+            }
+            return lines
+          }
+          return render(res.result, 0).join("\n")
+        }
+
+        case "diagnostics": {
+          const diags = proc._diagnostics?.[uri]
+          if (!diags?.length) return "No diagnostics."
+          return diags.slice(0, 30).map((d) => {
+            const sev = { 1: "ERROR", 2: "WARN", 3: "INFO", 4: "HINT" }[d.severity] || "?"
+            return `L${d.range.start.line + 1}: ${sev}: ${d.message}${d.code ? ` [${d.code}]` : ""}`
+          }).join("\n") + (diags.length > 30 ? `\n... and ${diags.length - 30} more` : "")
+        }
+
+        default:
+          return `Unknown subcommand: ${args.subcommand}`
+      }
+    } catch (err) {
+      return `LSP error: ${err.message}`
+    }
+  },
+}
+
+function symbolKind(k) {
+  const kinds = { 1: "file", 2: "module", 3: "namespace", 4: "package", 5: "class", 6: "method", 7: "property", 8: "field", 9: "constructor", 10: "enum", 11: "interface", 12: "function", 13: "variable", 14: "constant", 15: "string", 16: "number", 17: "boolean", 18: "array", 19: "object", 20: "key", 21: "null", 22: "enumMember", 23: "struct", 24: "event", 25: "operator", 26: "typeParameter" }
+  return kinds[k] || `kind-${k}`
+}

package/src/tools/web.mjs

@@ -1,11 +1,48 @@
-import {
-  DESC,
-  truncate,
-  readBodyText,
-  stripTags,
-  htmlToText
-} from "./shared.mjs";
-import { join } from "node:path";
+import { DESC, truncate, stripTags, htmlToText } from "./shared.mjs";
+import { URL } from "node:url";
+import { resolveWebProxy, proxyFetch } from "../proxy.mjs";
+
+export const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+const FETCH_TIMEOUT = 15_000
+
+// ── Web search (Bing; direct by default, through proxy when configured and web toggle on) ──
+
+function extractBing(html) {
+  const results = []
+  const blocks = html.split('<li class="b_algo"').slice(1)
+  for (const block of blocks) {
+    const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
+    if (!link) continue
+    const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
+    results.push({ href: link[1], title: stripTags(link[2]), snippet: snippet ? stripTags(snippet[1]) : "" })
+  }
+  return results
+}
+
+function bingUrl(query, page) {
+  let u = `https://www.bing.com/search?q=${encodeURIComponent(query)}&setlang=en&setmkt=en-US`
+  if (page > 1) u += `&first=${(page - 1) * 10 + 1}`
+  return u
+}
+
+const ENGINES = [{ name: "bing", label: "Bing", url: bingUrl, extract: extractBing, ua: UA }]
+const ENGINE_NAMES = ENGINES.map(e => e.name)
+
+async function fetchEngine(engine, query, page, ctx) {
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT)
+  try {
+    const response = await proxyFetch(engine.url(query, page), {
+      headers: { "User-Agent": engine.ua, "Accept-Language": "en-US,en;q=0.9,zh-CN;q=0.8" },
+      signal: ctrl.signal,
+    }, resolveWebProxy(ctx))
+    if (!response.ok) return null
+    const html = await response.text()
+    const results = engine.extract(html)
+    return { engine: engine.name, results }
+  } catch { return null }
+  finally { clearTimeout(timer) }
+}
 
 export const websearchTool = {
   name: "websearch",
@@ -14,108 +51,92 @@ export const websearchTool = {
     type: "object",
     properties: {
       query: { type: "string", description: "Search query" },
-      limit: { type: "number", description: "Max results (default 8)" },
+      limit: { type: "number", description: "Max results (default 8, max 20)" },
+      engine: { type: "string", enum: ENGINE_NAMES, description: "Specific engine — \"bing\" (Bing). Omit to search all engines concurrently." },
+      page: { type: "number", description: "Page number for pagination (1-based, default 1). Only used when engine is specified." },
     },
     required: ["query"],
   },
   readonly: true,
   async execute(args, ctx) {
-    const limit = args.limit ?? 8
-    const url = `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`
-    let html
-    try {
-      const response = await fetch(url, {
-        headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
-        signal: ctx?.signal
-          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(15_000)])
-          : AbortSignal.timeout(15_000),
-      })
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
-      html = await readBodyText(response)
-    } catch (error) {
-      throw new Error(`websearch request failed: ${error.cause?.code ?? error.message}`)
+    const limit = Math.min(args.limit ?? 8, 20)
+    const page = Math.max(1, args.page ?? 1)
+    if (args.engine) {
+      const engine = ENGINES.find(e => e.name === args.engine)
+      if (!engine) return `Unknown engine '${args.engine}'. Available: ${ENGINE_NAMES.join(", ")}`
+      const fetched = await fetchEngine(engine, args.query, page, ctx)
+      if (!fetched || fetched.results.length === 0) return `(no results from ${engine.label})`
+      return truncate(fetched.results.slice(0, limit).map((r, i) => `${i + 1}. ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
     }
-
-    // Result block <li class="b_algo">: <h2><a href>title</a></h2> + <p>snippet</p>
-    const blocks = html.split('<li class="b_algo"').slice(1)
-    const results = []
-    for (const block of blocks) {
-      const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
-      if (!link) continue
-      const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
-      results.push({
-        href: link[1],
-        title: stripTags(link[2]),
-        snippet: snippet ? stripTags(snippet[1]) : "",
-      })
-      if (results.length >= limit) break
+    const promises = ENGINES.map(e => fetchEngine(e, args.query, 1, ctx))
+    const fetched = (await Promise.all(promises)).filter(Boolean)
+    if (fetched.length === 0) return "(no results — all search engines failed)"
+    const merged = [], indexes = fetched.map(() => 0)
+    let done = false
+    while (!done && merged.length < limit) {
+      done = true
+      for (let i = 0; i < fetched.length; i++) {
+        if (indexes[i] < fetched[i].results.length) {
+          merged.push({ ...fetched[i].results[indexes[i]], _engine: fetched[i].engine })
+          indexes[i]++; done = false
+          if (merged.length >= limit) break
+        }
+      }
     }
-    if (results.length === 0) return "(no results)"
-    return truncate(
-      results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"),
-    )
+    return truncate(merged.slice(0, limit).map((r, i) => `${i + 1}. [${r._engine}] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
   },
 }
 
+// ── Fetch tool (with proxy support) ──────
 
-// ---------------------------------------------------------------- ls
-
-/** SSRF protection: block internal private-network/metadata endpoints (localhost allowed — user's dev server, tests depend on it) */
 function isPrivateUrl(urlStr) {
-  let u
-  try { u = new URL(urlStr) } catch { return true }
+  let u; try { u = new URL(urlStr) } catch { return true }
   const host = u.hostname.toLowerCase()
-  // localhost / 127.x allowed (user's dev server on local machine, test mock server)
   if (host === "localhost" || host === "0.0.0.0" || host.endsWith(".localhost")) return false
   if (host === "127.0.0.1" || host.startsWith("127.")) return false
-  // cloud metadata endpoint
   if (host === "169.254.169.254" || host === "metadata.google.internal") return true
-  // IPv4 private ranges
   const m = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
-  if (m) {
-    const [a, b] = [Number(m[1]), Number(m[2])]
-    if (a === 10) return true
-    if (a === 172 && b >= 16 && b <= 31) return true
-    if (a === 192 && b === 168) return true
-    if (a === 169 && b === 254) return true
-    if (a === 0) return true
-  }
-  // IPv6 loopback / link-local / unique local addresses
+  if (m) { const [a, b] = [Number(m[1]), Number(m[2])]; if (a === 10||a === 172&&b>=16&&b<=31||a === 192&&b===168||a === 169&&b===254||a===0) return true }
   if (host === "::1" || host === "fe80::1" || host.startsWith("fc") || host.startsWith("fd")) return true
   return false
 }
 
+// proxyFetch returns a native Response (Headers object, needs .get()) without proxy,
+// but a Response-like with a plain lowercase-keyed Record through the CONNECT tunnel — handle both.
+function headerOf(res, name) {
+  const h = res.headers
+  if (!h) return null
+  if (typeof h.get === "function") return h.get(name)
+  return h[name.toLowerCase()] ?? null
+}
+
 export const fetchTool = {
   name: "fetch",
   description: DESC("fetch"),
-  parameters: {
-    type: "object",
-    properties: {
-      url: { type: "string", description: "http/https URL" },
-    },
-    required: ["url"],
-  },
+  parameters: { type: "object", properties: { url: { type: "string", description: "http/https URL" } }, required: ["url"] },
   readonly: true,
   async execute(args, ctx) {
     if (!/^https?:\/\//.test(args.url)) throw new Error("url must start with http:// or https://")
     if (isPrivateUrl(args.url)) throw new Error("fetch blocked: internal/private/metadata addresses are not allowed")
-    let response
     try {
-      response = await fetch(args.url, {
-        headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
-        redirect: "follow",
-        signal: ctx?.signal
-          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)])
-          : AbortSignal.timeout(20_000),
-      })
-    } catch (error) {
-      throw new Error(`fetch failed: ${error.cause?.code ?? error.message}`)
-    }
-    if (!response.ok) throw new Error(`fetch failed: HTTP ${response.status}`)
-
-    const contentType = response.headers.get("content-type") ?? ""
-    const body = await readBodyText(response)
-    if (!contentType.includes("text/html")) return truncate(body)
-    return truncate(htmlToText(body))
+      const proxyUri = resolveWebProxy(ctx)
+      const response = await proxyFetch(args.url, { headers: { "User-Agent": UA } }, proxyUri)
+      if (!response.ok) {
+        if ([301, 302, 307, 308].includes(response.status)) {
+          const loc = headerOf(response, "location")
+          if (loc) {
+            const r2 = await proxyFetch(loc, { headers: { "User-Agent": UA } }, proxyUri)
+            if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}`)
+            const ct2 = headerOf(r2, "content-type") ?? ""
+            const b2 = await r2.text()
+            return ct2.includes("text/html") ? truncate(htmlToText(b2)) : truncate(b2)
+          }
+        }
+        throw new Error(`fetch failed: HTTP ${response.status}`)
+      }
+      const ct = headerOf(response, "content-type") ?? ""
+      const body = await response.text()
+      return ct.includes("text/html") ? truncate(htmlToText(body)) : truncate(body)
+    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`) }
   },
 }

package/src/tools/websearch.md

@@ -1,11 +1,13 @@
-Search the web (Bing). Returns result titles, URLs, and snippets. Use for looking up current information, docs, error messages.
+Search the web via Bing. Returns result titles, URLs, and snippets. Use for looking up current information, docs, error messages.
 
 Parameters:
 - query (required): Search query
-- limit: Max results (default 8)
+- limit: Max results (default 8, max 20)
+- engine: Specific engine to use — "bing" (Bing). Omit to search all engines concurrently.
+- page: Page number for pagination (1-based, default 1). Only used when engine is specified.
 
 Notes:
 - Before searching the web, call `memory_search` first — you may already know the answer from a previous session. Only reach for websearch if memory comes up empty.
 - Use this for information that is NOT in the local codebase — current docs, error messages, API references
 - Follow up with `fetch` to read full pages from the results
-- Results are scraped from Bing HTML — some formatting may be imperfect
+- Proxy support: set `"proxy": {"uri": "http://host:port", "web": true}` in config.json

package/src/tui/agent-turn.mjs

@@ -10,6 +10,9 @@ import { ansi, C } from "./ansi.mjs"
  *         handleSlash, summarize } */
 export async function runAgentTurn(ctx, text) {
   const { agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel, askPermission, askQuestion, handleSlash, summarize } = ctx
+  // 可注入覆盖（测试用）；默认走真实实现
+  const runAgentImpl = ctx.runAgent ?? runAgent
+  const saveSessionImpl = ctx.saveSession ?? saveSession
   pushLabel(`❯ You:`, ansi.bold + C.user)
   pushLine(text, C.text)
 
@@ -205,14 +208,14 @@ export async function runAgentTurn(ctx, text) {
       let n = 0
       return () => {
         if (++n % 5 !== 0) return
-        try { saveSession(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
+        try { saveSessionImpl(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
       }
     })(),
   }
 
   for (let resume = false; ; resume = true) {
     try {
-      await runAgent(agent, text, callbacks, { signal: state.controller.signal, resume })
+      await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume })
       flushStream()
       break // Normal completion, exit loop
     } catch (error) {
@@ -268,28 +271,24 @@ export async function runAgentTurn(ctx, text) {
   }
   // Save session after every turn (survives crashes)
   try {
-    saveSession(agent, state.lines)
+    saveSessionImpl(agent, state.lines)
   } catch {
     // Save failure doesn't interrupt usage
   }
   render()
 
   // Queued messages: auto-process next one
-  if (state.queue.length > 0) {
+  while (state.queue.length > 0 && !state.processing) {
     const next = state.queue.shift()
-    // Queued slash commands execute directly
+    // Queued slash commands execute directly — check every item, not just the first
     if (next.text.startsWith("/")) {
       await handleSlash(next.text)
       render()
-      // After slash command completes, continue checking queue
-      if (state.queue.length > 0 && !state.processing) {
-        const next2 = state.queue.shift()
-        await runAgentTurn(ctx, next2.text)
-      }
-    } else {
-      pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
-      await runAgentTurn(ctx, next.text)
+      continue
     }
+    pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
+    await runAgentTurn(ctx, next.text)
+    return
   }
 }