thincoder 0.12.36 → 0.12.38

package/src/tools/grep.md

@@ -1,9 +1,11 @@
 Search file contents with a regex. Returns matching lines as path:line: content.
 
 Parameters:
-- pattern (required): JavaScript regular expression
+- pattern (required): JavaScript regular expression, or a literal string when literal=true
 - path: Directory or file to search (default cwd)
 - glob: Only search files matching this glob (e.g. '*.mjs')
+- ignoreCase: Case-insensitive match (default false)
+- literal: Literal string match — no regex interpretation (default false; use for strings with `. \` etc.)
 - before: Lines of context to show before each match (grep -B). Default 0
 - after: Lines of context to show after each match (grep -A). Default 0
 

package/src/tools/index.mjs

@@ -10,6 +10,8 @@ import { checklistTool } from "./checklist.mjs";
 import { lintTool } from "./linter.mjs";
 import { lspTool } from "./lsp.mjs";
 import { codeModeTool } from "./codemode.mjs";
+import { fileOpsTool, processTool, getCurrentTimeTool, sleepTool } from "./ops.mjs";
+import { treeTool } from "./tree.mjs";
 
 export const builtinTools = [
   readTool, writeTool, editTool, insertAfterTool, hashlineEditTool, applyPatchTool,
@@ -17,6 +19,8 @@ export const builtinTools = [
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, codeModeTool,
+  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  treeTool,
 ];
 
 export {
@@ -25,4 +29,6 @@ export {
   websearchTool, lsTool, fetchTool, deleteTool,
   gitTool, questionTool,
   checklistTool, lintTool, lspTool, codeModeTool,
-};
+  fileOpsTool, processTool, getCurrentTimeTool, sleepTool,
+  treeTool,
+};

package/src/tools/ls.md

@@ -2,6 +2,7 @@ List directory contents with type, size, and modification time. Directories list
 
 Parameters:
 - path: Directory path (default cwd)
+- filter: Only list entries matching this glob (e.g. '*.mjs', '*test*') — a wildcard filter, not a full listing
 
 Notes:
 - Shows first 500 entries

package/src/tools/ops.mjs

@@ -0,0 +1,142 @@
+/**
+ * ops.mjs — operational tools: file_ops (move/copy/rename), process (list),
+ * get_current_time, sleep. Each exists so the model reaches for a dedicated tool
+ * instead of shelling out to `bash` for the same operation (parity with thinworker).
+ */
+import { DESC, resolveInCwd, truncate } from "./shared.mjs"
+import { cp, rename, rm } from "node:fs/promises"
+import { execFileSync } from "node:child_process"
+
+// ─── file_ops ──────────────────────────────────────────────────
+
+export const fileOpsTool = {
+  name: "file_ops",
+  description: DESC("file_ops"),
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["move", "copy", "rename"], description: "move | copy | rename" },
+      source: { type: "string", description: "Source path, relative to cwd or absolute" },
+      dest: { type: "string", description: "Destination path" },
+    },
+    required: ["action", "source", "dest"],
+  },
+  readonly: false,
+  async execute({ action, source, dest }, ctx) {
+    if (typeof source !== "string" || !source) return "Error: source is required"
+    if (typeof dest !== "string" || !dest) return "Error: dest is required"
+    if (!["move", "copy", "rename"].includes(action)) return `Error: action must be move | copy | rename (got "${action}")`
+    const src = resolveInCwd(ctx, source)
+    const dst = resolveInCwd(ctx, dest)
+    if (src === dst) return "Error: source and dest resolve to the same path"
+
+    if (action === "copy") {
+      await cp(src, dst, { recursive: true, force: true })
+      return `Copied ${source} → ${dest}`
+    }
+    // move & rename share the rename syscall; cross-device move falls back to copy+rm.
+    try {
+      await rename(src, dst)
+    } catch (e) {
+      if (e?.code !== "EXDEV") throw e
+      await cp(src, dst, { recursive: true, force: true })
+      await rm(src, { recursive: true, force: true })
+    }
+    return `${action === "rename" ? "Renamed" : "Moved"} ${source} → ${dest}`
+  },
+}
+
+// ─── process ───────────────────────────────────────────────────
+
+export const processTool = {
+  name: "process",
+  description: DESC("process"),
+  parameters: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Optional name substring filter (case-insensitive)" },
+    },
+  },
+  readonly: true,
+  async execute({ name }, ctx) {
+    const filter = typeof name === "string" && name.trim() ? name.trim().toLowerCase() : null
+    let rows
+    try {
+      rows = process.platform === "win32" ? listWindows() : listPosix()
+    } catch (e) {
+      return `process listing failed: ${e?.message ?? String(e)}`
+    }
+    if (filter) rows = rows.filter((r) => r.name.toLowerCase().includes(filter))
+    if (rows.length === 0) return filter ? `No running processes match "${name}"` : "(no processes)"
+    return truncate(rows.map((r) => `${r.name}\tPID ${r.pid}${r.mem ? `\t${r.mem}` : ""}`).join("\n"))
+  },
+}
+
+function listWindows() {
+  // tasklist /FO CSV /NH → lines: "name.exe","1234","Console","1","12,345 K"
+  const out = execFileSync("tasklist", ["/FO", "CSV", "/NH"], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const parts = line.split('","')
+    if (parts.length < 2) continue
+    const name = parts[0].replace(/^"/, "").trim()
+    const pid = parts[1].replace(/"/, "").trim()
+    const mem = parts[4] ? parts[4].replace(/"/, "").trim() : ""
+    if (!name || !pid) continue
+    rows.push({ name, pid, mem })
+  }
+  return rows
+}
+
+function listPosix() {
+  const out = execFileSync("ps", ["-eo", "pid=,comm="], { encoding: "utf8", timeout: 10000 })
+  const rows = []
+  for (const line of out.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(.+)$/)
+    if (m) rows.push({ name: m[2], pid: m[1], mem: "" })
+  }
+  return rows
+}
+
+// ─── get_current_time ──────────────────────────────────────────
+
+export const getCurrentTimeTool = {
+  name: "get_current_time",
+  description: DESC("get_current_time"),
+  parameters: { type: "object", properties: {} },
+  readonly: true,
+  async execute() {
+    const now = new Date()
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone ?? "unknown"
+    const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+    return `Date: ${now.toISOString()} (UTC)\nTimezone: ${tz}\nWeekday: ${days[now.getDay()]}\nLocal: ${now.toLocaleString()}`
+  },
+}
+
+// ─── sleep ─────────────────────────────────────────────────────
+
+export const sleepTool = {
+  name: "sleep",
+  description: DESC("sleep"),
+  parameters: {
+    type: "object",
+    properties: {
+      seconds: { type: "number", description: "Seconds to wait (1-300)" },
+      reason: { type: "string", description: "Why wait (shown to the user)" },
+    },
+    required: ["seconds"],
+  },
+  readonly: true,
+  async execute({ seconds, reason }, ctx) {
+    const raw = Number(seconds)
+    const n = Number.isFinite(raw) ? Math.min(Math.max(Math.round(raw), 1), 300) : 1
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(resolve, n * 1000)
+      if (ctx?.signal) {
+        if (ctx.signal.aborted) { clearTimeout(t); reject(new Error("aborted")) }
+        else ctx.signal.addEventListener("abort", () => { clearTimeout(t); reject(new Error("aborted")) }, { once: true })
+      }
+    })
+    return `Waited ${n}s${reason ? ` (${reason})` : ""}`
+  },
+}

package/src/tools/process.md

@@ -0,0 +1,10 @@
+List running processes, optionally filtered by name. Returns process name / PID / memory.
+
+**Route to process instead of bash:**
+- `tasklist` (Windows) / `ps aux` (POSIX) → process
+
+Parameters:
+- name (optional): substring filter (case-insensitive), e.g. "node", "python"
+
+Notes:
+- List-only. To kill a process, use `bash taskkill /PID <pid> /F` (Windows) or `bash kill <pid>` — and confirm with the user first.

package/src/tools/sleep.md

@@ -0,0 +1,5 @@
+Wait a number of seconds before continuing. Use to wait for a web page to load, an async task to finish, or to respect a rate limit — cheaper than repeatedly polling.
+
+Parameters:
+- seconds (required): how many seconds to wait (1-300)
+- reason (optional): why you are waiting (shown to the user)

package/src/tools/system.mjs

@@ -17,6 +17,20 @@ import { join } from "node:path";
 /** Maximum buffer size per stream (stdout / stderr) before truncation */
 const MAX_STREAM_BUF = 2_000_000
 
+/** Escape a string for literal regex matching (grep literal=true). */
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+/** Keep only output lines matching a regex (bash filter, case-insensitive). */
+function applyLineFilter(output, filter) {
+  let re
+  try { re = new RegExp(filter, "i") } catch (e) { return `Error: filter regex invalid: ${e.message}` }
+  const lines = output.split("\n").filter((l) => re.test(l))
+  if (lines.length === 0) return `(no output lines matched filter "${filter}")`
+  return truncate(lines.join("\n"))
+}
+
 // ====================================================================
 // bash — command execution with safety gates
 // ====================================================================
@@ -223,6 +237,7 @@ export const bashTool = {
     properties: {
       command: { type: "string", description: "Shell command to execute" },
       timeout: { type: "number", description: `Timeout in ms (default ${BASH_TIMEOUT_MS})` },
+      filter: { type: "string", description: "Optional: only return output lines matching this regex (case-insensitive)" },
     },
     required: ["command"],
   },
@@ -241,7 +256,8 @@ export const bashTool = {
       onOutput: ctx.onOutput,
       shell: ctx.agent?.config?.shell ?? null,
     })
-    return guard ? `${guard.notice}\n\n${result}` : result
+    const filtered = args.filter ? applyLineFilter(result, args.filter) : result
+    return guard ? `${guard.notice}\n\n${filtered}` : filtered
   },
 }
 
@@ -305,9 +321,11 @@ export const grepTool = {
   parameters: {
     type: "object",
     properties: {
-      pattern: { type: "string", description: "Regular expression" },
+      pattern: { type: "string", description: "Regular expression, or a literal string when literal=true" },
       path: { type: "string", description: "Directory or file to search (default cwd)" },
       glob: { type: "string", description: "Only search files matching this glob (e.g. '*.mjs')" },
+      ignoreCase: { type: "boolean", description: "Case-insensitive match (default false)" },
+      literal: { type: "boolean", description: "Literal string match — no regex interpretation (default false)" },
       before: { type: "integer", description: "Lines of context to show before each match (grep -B). Default 0" },
       after: { type: "integer", description: "Lines of context to show after each match (grep -A). Default 0" },
     },
@@ -318,7 +336,8 @@ export const grepTool = {
     const base = resolveInCwd(ctx, args.path ?? ".")
     let regex
     try {
-      regex = new RegExp(args.pattern)
+      const pat = args.literal ? escapeRegExp(String(args.pattern)) : args.pattern
+      regex = new RegExp(pat, args.ignoreCase ? "i" : "")
     } catch (e) {
       throw new Error(`grep pattern /${args.pattern}/ is not a valid regex: ${e.message}`)
     }
@@ -409,11 +428,13 @@ export const lsTool = {
     type: "object",
     properties: {
       path: { type: "string", description: "Directory path (default cwd)" },
+      filter: { type: "string", description: "Only list entries matching this glob (e.g. '*.mjs', '*test*')" },
     },
   },
   readonly: true,
   async execute(args, ctx) {
     const abs = resolveInCwd(ctx, args.path ?? ".")
+    const filterRe = args.filter ? globToRegex(args.filter) : null
     let entries
     try {
       entries = await readdir(abs, { withFileTypes: true })
@@ -422,7 +443,10 @@ export const lsTool = {
       throw e
     }
     const rows = await Promise.all(
-      entries.slice(0, 500).map(async (e) => {
+      entries
+        .filter((e) => !filterRe || filterRe.test(e.name))
+        .slice(0, 500)
+        .map(async (e) => {
         const s = await stat(join(abs, e.name)).catch(() => null)
         const isDir = e.isDirectory()
         return {
@@ -439,5 +463,3 @@ export const lsTool = {
     return truncate(out.join("\n"))
   },
 }
-
-// ---------------------------------------------------------------- fetch

package/src/tools/tree.md

@@ -0,0 +1,13 @@
+Generate a directory tree of the codebase (default depth 3). Skips dotfiles, .git/node_modules/dist/build/bin/obj and other build/vendor dirs, and binary files. Use to quickly see which modules exist and where files live.
+
+**Route to tree instead of bash:**
+- `tree` / `find .` / `dir /s` → tree
+
+Parameters:
+- path: Root directory (default cwd)
+- depth: Tree depth (default 3, max 6). Directories are listed before files, both sorted.
+
+Notes:
+- Capped at 200 entries.
+- Directories end with `/`; tree-drawing uses `├──`/`└──`/`│`.
+- Use depth for a shallow overview; use `ls` for one directory, `glob` for a specific file pattern.

package/src/tools/tree.mjs

@@ -0,0 +1,66 @@
+/**
+ * tree.mjs — directory tree tool (parity with thinworker `repomap`).
+ * Renders a repo's directory tree (default depth 3), skipping dotfiles,
+ * build/vendor dirs and binary files, so the model can see which modules
+ * exist without shelling out to `tree`/`find`.
+ */
+import { DESC, truncate, resolveInCwd } from "./shared.mjs"
+import { readdir, stat } from "node:fs/promises"
+import { join, basename, extname } from "node:path"
+
+const MAX_ENTRIES = 200
+const DEFAULT_DEPTH = 3
+const SKIP_DIRS = new Set(["node_modules", "bin", "obj", "dist", "build", "coverage", "turbo", ".git", ".thincoder", ".vs", ".venv", "__pycache__", ".idea"])
+const BINARY_EXTS = new Set([".exe", ".dll", ".png", ".jpg", ".jpeg", ".gif", ".pdf", ".docx", ".xlsx", ".pptx", ".zip", ".7z", ".mp3", ".mp4", ".woff", ".woff2", ".ico"])
+
+export const treeTool = {
+  name: "tree",
+  description: DESC("tree"),
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "Root directory (default cwd)" },
+      depth: { type: "integer", description: `Tree depth (default ${DEFAULT_DEPTH}, max 6)` },
+    },
+    required: [],
+  },
+  readonly: true,
+  async execute(args, ctx) {
+    const root = resolveInCwd(ctx, args.path ?? ".")
+    let st
+    try { st = await stat(root) } catch { return `Error: directory not found: ${args.path ?? "."}` }
+    if (!st.isDirectory()) return `Error: not a directory: ${args.path ?? "."}`
+    const d = Number(args.depth)
+    const maxDepth = Number.isInteger(d) && d > 0 ? Math.min(d, 6) : DEFAULT_DEPTH
+    const lines = [basename(root) + "/"]
+    const state = { count: 1, capped: false }
+    await walk(root, 0, maxDepth, "", lines, state)
+    return truncate(lines.join("\n"))
+  },
+}
+
+async function walk(dir, depth, maxDepth, prefix, lines, state) {
+  if (state.capped) return
+  let entries
+  try { entries = await readdir(dir, { withFileTypes: true }) } catch { return }
+  const items = []
+  for (const e of entries) {
+    if (e.name.startsWith(".")) continue // dotfiles + dotdirs
+    const isDir = e.isDirectory()
+    if (isDir) { if (SKIP_DIRS.has(e.name)) continue; items.push({ name: e.name, isDir: true }) }
+    else if (!BINARY_EXTS.has(extname(e.name).toLowerCase())) items.push({ name: e.name, isDir: false })
+  }
+  items.sort((a, b) => (a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1))
+
+  for (let i = 0; i < items.length; i++) {
+    if (state.capped) return
+    if (state.count >= MAX_ENTRIES) { state.capped = true; lines.push(prefix + "…（更多项已省略）"); return }
+    const { name, isDir } = items[i]
+    const isLast = i === items.length - 1
+    lines.push(prefix + (isLast ? "└── " : "├── ") + (isDir ? name + "/" : name))
+    state.count++
+    if (isDir && depth + 1 < maxDepth) {
+      await walk(join(dir, name), depth + 1, maxDepth, prefix + (isLast ? "    " : "│   "), lines, state)
+    }
+  }
+}

package/src/tui/clipboard.mjs

@@ -1,5 +1,12 @@
 import { C } from "./ansi.mjs"
 
+/** Windows clipboard-read command: force UTF-8 console output so Get-Clipboard's bytes
+ *  are decoded by Node's default UTF-8 (not the OEM codepage / GBK) — IK9UWM. Exported
+ *  for unit tests (TUI.md §9.2D). */
+export function buildWindowsClipboardCommand() {
+  return ["-NoProfile", "-Command", "[Console]::OutputEncoding=[Text.Encoding]::UTF8; Get-Clipboard"]
+}
+
 /** Read text from system clipboard. Returns empty string on failure. */
 export async function readClipboardText() {
   try {
@@ -7,7 +14,9 @@ export async function readClipboardText() {
     const isWin = process.platform === "win32"
     const isMac = process.platform === "darwin"
     if (isWin) {
-      return await new Promise((resolve) => execFile("powershell", ["-NoProfile", "-Command", "Get-Clipboard"], { timeout: 5000 }, (err, stdout) => resolve(err ? "" : stdout)))
+      // Strip a leading \uFEFF — PowerShell may prepend a UTF-8 BOM once OutputEncoding
+      // flips to UTF-8 (TUI.md §9.2D BOM defense).
+      return await new Promise((resolve) => execFile("powershell", buildWindowsClipboardCommand(), { timeout: 5000 }, (err, stdout) => resolve(err ? "" : String(stdout).replace(/^\uFEFF/, ""))))
     } else if (isMac) {
       return await new Promise((resolve) => execFile("pbpaste", [], { timeout: 5000 }, (err, stdout) => resolve(err ? "" : stdout)))
     } else {
@@ -18,6 +27,49 @@ export async function readClipboardText() {
   }
 }
 
+/** Write text to the system clipboard. Returns true on success, false on failure. */
+export async function writeClipboardText(text) {
+  if (typeof text !== "string" || text.length === 0) return false
+  try {
+    const { spawn } = await import("node:child_process")
+    const isWin = process.platform === "win32"
+    const isMac = process.platform === "darwin"
+
+    if (isWin) {
+      // -EncodedCommand is base64 UTF-16LE: PowerShell decodes the command (embedded text
+      // included) directly from UTF-16, so no console codepage (e.g. GBK) can garble
+      // non-ASCII characters — the same class of bug as the read path (IK9UWM).
+      const psCmd = `Set-Clipboard -Value '${text.replace(/'/g, "''")}'`
+      const encoded = Buffer.from(psCmd, "utf16le").toString("base64")
+      await spawnWait(spawn, "powershell", ["-NoProfile", "-EncodedCommand", encoded], null)
+      return true
+    }
+    if (isMac) {
+      await spawnWait(spawn, "pbcopy", [], text)
+      return true
+    }
+    // Linux: prefer wl-copy (Wayland), fall back to xclip (X11).
+    await spawnWait(spawn, "sh", ["-c", "command -v wl-copy >/dev/null 2>&1 && wl-copy || xclip -selection clipboard"], text)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Spawn a process and wait for clean exit. When stdinText is provided it is piped to
+ *  the child as UTF-8 (used by pbcopy / xclip / wl-copy); otherwise stdio is ignored. */
+function spawnWait(spawn, cmd, args, stdinText) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: stdinText == null ? "ignore" : ["pipe", "ignore", "ignore"] })
+    child.once("error", reject)
+    child.once("close", (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`))))
+    if (stdinText != null) {
+      child.stdin.on("error", () => {}) // swallow EPIPE when the tool exits without draining
+      child.stdin.end(stdinText, "utf8")
+    }
+  })
+}
+
 /** Insert pasted text into the active text target.
  *  Free-text question active → append to its answer (single-line field: newlines stripped).
  *  Options question active → ignore (no text field; must not leak into the input box).

package/src/tui/cmd-advisor.mjs

@@ -29,7 +29,7 @@ export async function handleAdvisorCommand(ctx) {
       : cfg.thinking?.type === "disabled" ? "off"
       : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
       : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
-    return `Advisor: always available | Model: ${curModel} | Think: ${thinkInfo}`
+    return `Advisor | Model: ${curModel} | Think: ${thinkInfo}`
   }
 
   function headerLine() {
@@ -115,7 +115,7 @@ export async function handleAdvisorCommand(ctx) {
       { type: "header", text: headerLine() },
       { type: "item", text: `Model: ${curModel}`, action: "model", note: `Provider: ${curProvider}` },
       { type: "item", text: `Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, action: "thinking" },
-      { type: "item", text: `Guard: ${guardInfo}`, action: "guard" },
+      { type: "item", text: `Advisor: ${guardInfo}`, action: "guard" },
       { type: "item", text: "View full config", action: "view" },
     ]
 
@@ -125,9 +125,8 @@ export async function handleAdvisorCommand(ctx) {
 
     if (choice.action === "view") {
       pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Status:   always available`, C.dim)
       pushLine(`Model:    ${curModel} (provider: ${curProvider})`, C.dim)
-      pushLine(`Guard:    ${guardInfo}`, C.dim)
+      pushLine(`Advisor:    ${guardInfo}`, C.dim)
       pushLine(`Thinking: ${advisorStatus().split("|")[2]?.trim() || "(main)"}`, C.dim)
       continue
     }
@@ -136,7 +135,7 @@ export async function handleAdvisorCommand(ctx) {
       cfg.guard = !(cfg.guard === true)
       await persist().catch(err => pushLine(`[error] ${err.message}`, C.error))
       pushLabel("❯ Advisor", ansi.bold + C.tool)
-      pushLine(`Guard: ${cfg.guard === true ? "on" : "off"}`, C.tool)
+      pushLine(`Advisor: ${cfg.guard === true ? "on" : "off"}`, C.tool)
       continue
     }
 

package/src/tui/cmd-config.mjs

@@ -1,10 +1,22 @@
 import { existsSync, readFileSync } from "node:fs"
 import { ansi, C } from "./ansi.mjs"
+/** Merge an embedding-key save into the raw config, backfilling baseURL/model from defaults.
+ *  Keeps existing custom values (Ollama/local embedding); defaults are the single source
+ *  (TUI.md §9.3D — NF1). Exported for unit tests. */
+export function embeddingPatch(raw, embKey, defaults) {
+  const prev = raw?.embedding ?? {}
+  return {
+    ...prev,
+    apiKey: embKey,
+    baseURL: prev.baseURL ?? defaults.baseURL,
+    model: prev.model ?? defaults.model,
+  }
+}
 
 /** /config command: view and set agent/embedding/proxy config. */
 export async function handleConfigCommand(ctx, args = []) {
   const { agent, pushLine, pushLabel, showPicker, askQuestion, persistRaw, maskKey, pickModelForSlot } = ctx
-  const { configPath } = await import("../config.mjs")
+  const { configPath, DEFAULTS } = await import("../config.mjs")
   const ac = agent.config?.agent ?? {}
   const ec = agent.config?.embedding ?? {}
 
@@ -20,7 +32,7 @@ export async function handleConfigCommand(ctx, args = []) {
     if (!embKey) return false
     agent.config.embedding ??= {}
     agent.config.embedding.apiKey = embKey
-    await persistRaw((raw) => { raw.embedding = { ...(raw.embedding ?? {}), apiKey: embKey } })
+    await persistRaw((raw) => { raw.embedding = embeddingPatch(raw, embKey, DEFAULTS.embedding) })
     if (agent.memory) {
       const { createEmbedder } = await import("../embedding.mjs")
       agent.memory.embedder = createEmbedder(agent.config.embedding)

package/src/tui/cmd-copy.mjs

@@ -0,0 +1,29 @@
+/**
+ * cmd-copy.mjs — /copy command: copy the last assistant response to the clipboard.
+ * Copies the RAW markdown reply (agent.history content), not the ANSI-styled display.
+ */
+import { C } from "./ansi.mjs"
+import { writeClipboardText } from "./clipboard.mjs"
+
+/** Most recent assistant reply with non-empty text content (skips tool-calls-only / transient). */
+export function lastAssistantContent(history) {
+  if (!Array.isArray(history)) return null
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i]
+    if (m?.role === "assistant" && typeof m.content === "string" && m.content.trim().length > 0) {
+      return m.content
+    }
+  }
+  return null
+}
+
+export async function handleCopyCommand(ctx) {
+  const { agent, pushLine } = ctx
+  const text = lastAssistantContent(agent?.history)
+  if (!text) {
+    pushLine("No assistant response to copy yet", C.warn)
+    return
+  }
+  const ok = await writeClipboardText(text)
+  pushLine(ok ? `Copied last response (${text.length} chars) to clipboard` : "Clipboard write failed", ok ? C.tool : C.error)
+}