thincoder 0.12.37 → 0.12.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thincoder",
-  "version": "0.12.37",
+  "version": "0.12.38",
   "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
   "keywords": [
     "ai",

package/src/agent-tools/consult.mjs

@@ -19,6 +19,36 @@ function consultLabel(m) {
   return `${m.provider}:${m.model}`
 }
 
+/** Narrow the configured consultModels pool to a requested subset.
+ *  Each selector is "provider:model", a bare provider name, or a bare model name
+ *  (case-insensitive). Returns { models, error } — error set when a selector matches
+ *  nothing (surface the typo rather than silently dropping it). Absent/empty selectors
+ *  → the full pool. */
+function selectConsultModels(pool, selectors) {
+  if (selectors == null || (Array.isArray(selectors) && selectors.length === 0)) return { models: pool, error: null }
+  const list = Array.isArray(selectors) ? selectors : [selectors] // coerce a bare string → [string]
+  const selected = []
+  const seen = new Set()
+  const unknowns = []
+  for (const raw of list) {
+    const s = String(raw).trim().toLowerCase()
+    const matches = pool.filter((m) =>
+      consultLabel(m).toLowerCase() === s ||
+      String(m.provider ?? "").toLowerCase() === s ||
+      String(m.model ?? "").toLowerCase() === s,
+    )
+    if (matches.length === 0) unknowns.push(String(raw))
+    else for (const m of matches) {
+      const key = consultLabel(m)
+      if (!seen.has(key)) { seen.add(key); selected.push(m) }
+    }
+  }
+  if (unknowns.length > 0) {
+    return { models: null, error: `unknown consult model selector(s): ${unknowns.join(", ")} — choose from: ${pool.map(consultLabel).join(", ")}` }
+  }
+  return { models: selected, error: null }
+}
+
 /** Read-only tool injected into consultation children (via createAgent's tools).
  *  Lets the consultant pull the main agent's conversation history on demand —
  *  the failure trail is first-class evidence, not a retelling. */
@@ -225,31 +255,40 @@ export const consultStartTool = {
     "arrives, judge/verify it yourself with your own tools, and call consult_stop(id) once a reply is good enough.\n" +
     "Parameters:\n" +
     "- problem (required): a brief — the symptom, what you already tried (failure trail), and entry-point files. " +
-    "Do NOT paste raw error logs; consultants pull the main session history themselves via their main_history tool.",
+    "Do NOT paste raw error logs; consultants pull the main session history themselves via their main_history tool.\n" +
+    "- models (optional): subset of agent.consultModels to run — an array of \"provider:model\", bare provider, or bare model names (case-insensitive). Omit to run all.",
   parameters: {
     type: "object",
-    properties: { problem: { type: "string", description: "Problem brief (symptom + failure trail + entry files)" } },
+    properties: {
+      problem: { type: "string", description: "Problem brief (symptom + failure trail + entry files)" },
+      models: { type: "array", items: { type: "string" }, description: 'Optional subset of agent.consultModels to run (default: all). Each entry is "provider:model", a bare provider name, or a bare model name (case-insensitive).' },
+    },
     required: ["problem"],
   },
-  async execute({ problem }, ctx) {
+  async execute({ problem, models }, ctx) {
     if (typeof problem !== "string" || !problem.trim()) return "Error: problem is required and must be a non-empty string"
     const agent = ctx.agent
     if (!agent) return "Error: consult requires an agent context"
-    const models = agent.config?.agent?.consultModels ?? []
-    if (!Array.isArray(models) || models.length === 0)
+    const pool = agent.config?.agent?.consultModels ?? []
+    if (!Array.isArray(pool) || pool.length === 0)
       return "Consultation is not configured — add agent.consultModels ([{ provider, model }], up to 5) to ~/.thincoder/config.json"
-    if (models.length > 5) return `Error: consultModels supports at most 5 models (got ${models.length})`
+    if (pool.length > 5) return `Error: consultModels supports at most 5 models (got ${pool.length})`
+
+    // `models` (optional) narrows the pool to a subset; absent/empty → run the whole pool.
+    const picked = selectConsultModels(pool, models)
+    if (picked.error) return picked.error
+    const run = picked.models
 
     agent._consultSessions ??= new Map()
     const id = String((agent._consultIdCounter = (agent._consultIdCounter ?? 0) + 1))
     const session = {
       id, controllers: [], replies: [], pending: 0, waiters: [],
-      failed: 0, terminated: 0, stopped: false, received: 0, total: models.length,
-      models: models.map(consultLabel),
+      failed: 0, terminated: 0, stopped: false, received: 0, total: run.length,
+      models: run.map(consultLabel),
     }
     agent._consultSessions.set(id, session)
 
-    for (const m of models) {
+    for (const m of run) {
       session.pending++
       const ctrl = new AbortController()
       session.controllers.push(ctrl)

package/src/agent-tools/verify.mjs

@@ -2,7 +2,7 @@ import { repairHistory, listWorkDir } from "../agent.mjs"
 import { isDocFile } from "../advisor/repos.mjs"
 import { execSync, spawn, spawnSync } from "node:child_process"
 import { readFileSync, existsSync } from "node:fs"
-import { join } from "node:path"
+import { join, resolve } from "node:path"
 
 /**
  * Source module → test file mapping. Heuristic: the FIRST path component
@@ -58,12 +58,17 @@ export const verifyTool = {
     type: "object",
     properties: {
       full: { type: "boolean", description: "Run the full test suite (npm test) instead of just related tests. Default false — use sparingly, per the testing discipline rules." },
+      workdir: { type: "string", description: "Optional: run verify in this subdirectory (relative to cwd or absolute) — for monorepos" },
+      filter: { type: "string", description: "Optional: limit the test run to matching test names (node --test-name-pattern / npm test -- --test-name-pattern)" },
     },
   },
   readonly: true,
   outputPanel: true, // stream test output to a panel instead of inline
   async execute(args, ctx) {
     const cwd = ctx.agent.cwd
+    // workdir only relocates WHERE tests (and package.json) live — changed-file
+    // resolution (git diff) stays anchored to the project root.
+    const testCwd = args.workdir ? resolve(cwd, args.workdir) : cwd
     const lines = []
     lines.push("=== VERIFICATION REPORT ===")
     lines.push("")
@@ -130,7 +135,7 @@ export const verifyTool = {
     const relatedTests = [...new Set(modules.map((m) => MODULE_TO_TEST[m]).filter(Boolean))]
 
     // 4. Run tests
-    const pkgPath = join(cwd, "package.json")
+    const pkgPath = join(testCwd, "package.json")
     const hasTestScript = existsSync(pkgPath) && (() => { try { return !!JSON.parse(readFileSync(pkgPath, "utf8")).scripts?.test } catch { return false } })()
 
     if (args.full) {
@@ -138,7 +143,7 @@ export const verifyTool = {
       if (hasTestScript) {
         lines.push("")
         lines.push("Tests (full suite):")
-        const result = await runTestSuite(cwd, ctx)
+        const result = await runTestSuite(testCwd, ctx, args.filter)
         if (result.passed) {
           lines.push("✓ All tests passed.")
           ctx.agent._verifyPassed = !syntaxFailed
@@ -163,7 +168,7 @@ export const verifyTool = {
           continue
         }
         try {
-          const result = await runTestFile(cwd, testFile, ctx)
+          const result = await runTestFile(cwd, testFile, ctx, args.filter)
           if (result.passed) {
             lines.push(`  ✓ ${testFile}`)
           } else {
@@ -248,9 +253,9 @@ export const verifyTool = {
  * Run a single test file with node --test, no maxBuffer limit.
  * Returns { passed: boolean, tail: string } — the last few lines of output.
  */
-function runTestFile(cwd, testPath, ctx) {
+function runTestFile(cwd, testPath, ctx, filter) {
   return new Promise((resolve, reject) => {
-    const child = spawn("node", ["--test", testPath], {
+    const child = spawn("node", filter ? ["--test", "--test-name-pattern", filter, testPath] : ["--test", testPath], {
       cwd, stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, FORCE_COLOR: "0" },
     })
@@ -288,9 +293,9 @@ function runTestFile(cwd, testPath, ctx) {
  * Test output is streamed through ctx.callbacks.onToolOutput (TUI can display progress in real time).
  * Returns { passed: boolean, tail: string }.
  */
-function runTestSuite(cwd, ctx) {
+function runTestSuite(cwd, ctx, filter) {
   return new Promise((resolve, reject) => {
-    const child = spawn("npm", ["test"], {
+    const child = spawn("npm", filter ? ["test", "--", `--test-name-pattern=${filter}`] : ["test"], {
       cwd, shell: true, stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, FORCE_COLOR: "0" },
     })

package/src/config.mjs

@@ -87,7 +87,7 @@ export const DEFAULTS = {
  * multimodal:        whether multimodal (image/vision input supported)
  * cacheMode:         context caching mode: "auto"=automatic / "prompt"=needs explicit / "none"=unsupported
  * thinkApi:          thinking API type: "type"=thinking.type field / "effort"=reasoning_effort field
- * thinkOnValue:      when thinkApi is "type", the value used to enable thinking (default "enabled"; MiniMax uses "adaptive")
+ * thinkEnabledValue: when thinkApi is "type", the value used to enable thinking (default "enabled"; MiniMax uses "adaptive")
  * reasoningEcho:     reasoning_content cross-turn echo strategy: "required"=must echo (error if missing) / "optional"=echo optional (default: don't echo)
  * reasoningEffortEnum: valid reasoning_effort enum values (if undeclared, no validation — passed through as-is)
  * tempRange:         valid temperature range [min, max] (if undeclared, no clamping)
@@ -96,6 +96,8 @@ const MODEL_SPECS = [
   // DeepSeek V4 series
   ["deepseek-v4-pro",   { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2] }],
   ["deepseek-v4-flash", { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2] }],
+  // DeepSeek V4 Flash Vision (experimental) — image input on top of the full V4-Flash stack
+  ["deepseek-v4-flash-vision-exp", { context: 1_000_000, maxOutput: 384_000, thinking: true,  prefixMode: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 2], multimodal: true }],
   // Kimi series
   ["kimi-k3",           { context: 1_000_000, maxOutput: 131_072, thinking: true,  partialMode: true, multimodal: true, cacheMode: "auto",  thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
   // Qwen router prefixes model IDs with provider namespace: kimi/kimi-k3 → kimi-k3 (IK7K4V)
@@ -103,17 +105,22 @@ const MODEL_SPECS = [
   // Kimi For Coding endpoint uses the short model ID "k3" (same specs as kimi-k3) — IK5VGJ
   ["k3",                { context: 1_000_000, maxOutput: 131_072, thinking: true,  partialMode: true, multimodal: true, cacheMode: "auto",  thinkApi: "effort", reasoningEcho: "required", reasoningEffortEnum: ["low", "high", "max"] }],
   // GLM series
+  // GLM-5.3: thinking always-on (no "disabled"); effort converges to low/high/max — NOT the
+  //          7-level glm-5.2 enum (verified vs docs.bigmodel.cn GLM-5.3 page, 2026-08)
+  ["glm-5.3",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "optional", reasoningEffortEnum: ["low", "high", "max"], tempRange: [0, 1], noUsageStream: true }],
   ["glm-5.2",           { context: 1_000_000, maxOutput: 128_000, thinking: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "optional", reasoningEffortEnum: ["max", "xhigh", "high", "medium", "low", "minimal", "none"], tempRange: [0, 1], noUsageStream: true }],
   ["glm-5",             { context: 1_000_000, maxOutput: 128_000, thinking: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "optional", reasoningEffortEnum: ["max", "xhigh", "high", "medium", "low", "minimal", "none"], tempRange: [0, 1], noUsageStream: true }],
   ["glm-4",             { context: 128_000,   maxOutput: 32_000,  thinking: true,  cacheMode: "auto", thinkApi: "type", reasoningEcho: "optional", tempRange: [0, 1], noUsageStream: true }],
   // GPT series
+  ["gpt-5.6-sol",       { context: 1_050_000, maxOutput: 128_000, thinking: false, multimodal: true, cacheMode: "prompt" }],
+  ["gpt-5.6",           { context: 1_050_000, maxOutput: 128_000, thinking: false, multimodal: true, cacheMode: "prompt" }],
   ["gpt-4.1",           { context: 1_000_000, maxOutput: 128_000, thinking: false, cacheMode: "prompt" }],
   ["gpt-4o",            { context: 128_000,   maxOutput: 16_000,  thinking: false, multimodal: true, cacheMode: "prompt" }],
   // Qwen series
-  ["qwen3.8-max-preview", { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
+  ["qwen3.8-max-preview", { context: 1_000_000, maxOutput: 131_072, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "medium", "low"], tempRange: [0, 2] }],
   // qwen3.7-max rejects image parts outright (DashScope 400 "Unexpected item type in content") — text-only
-  ["qwen3.7-max",       { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
-  ["qwen3.8-max",       { context: 1_000_000, maxOutput: 128_000, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "medium", "low"], tempRange: [0, 2] }],
+  ["qwen3.7-max",       { context: 1_000_000, maxOutput: 131_072, thinking: true, partialMode: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "high"], tempRange: [0, 2] }],
+  ["qwen3.8-max",       { context: 1_000_000, maxOutput: 131_072, thinking: true, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", reasoningEffortEnum: ["xhigh", "medium", "low"], tempRange: [0, 2] }],
   ["qwen-max",          { context: 1_000_000, maxOutput: 131_072, thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
   ["qwen-plus",         { context: 1_000_000, maxOutput: 131_072,  thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
   ["qwen",              { context: 1_000_000, maxOutput: 131_072, thinking: false, partialMode: true, multimodal: true, cacheMode: "none", thinkApi: "effort", tempRange: [0, 2] }],
@@ -127,6 +134,8 @@ const MODEL_SPECS = [
   ["minimax-m3",        { context: 1_000_000, maxOutput: 128_000, thinking: true,  multimodal: true, cacheMode: "auto", thinkApi: "type", thinkEnabledValue: "adaptive", tempRange: [0, 2], noUsageStream: true }],
   ["minimax-m1",        { context: 256_000,   maxOutput: 128_000, thinking: false, cacheMode: "auto", noUsageStream: true }],
   // Grok series (xAI — OpenAI-compatible)
+  // grok-4.x: 500K context per xAI Grok 4.6 spec (corrected 2026-08; earlier entries said 1M)
+  ["grok-4.6",          { context: 500_000,   maxOutput: 64_000,  thinking: false, multimodal: true, tempRange: [0, 2] }],
   ["grok-4.5",          { context: 500_000,   maxOutput: 64_000,  thinking: false, multimodal: true, tempRange: [0, 2] }],
   ["grok-4",            { context: 500_000,   maxOutput: 64_000,  thinking: false, multimodal: true, tempRange: [0, 2] }],
   ["grok-4-mini",       { context: 128_000,   maxOutput: 16_000,  thinking: false, tempRange: [0, 2] }],
@@ -134,10 +143,13 @@ const MODEL_SPECS = [
   ["mistral-large",     { context: 128_000,   maxOutput: 32_000,  thinking: false, multimodal: true, tempRange: [0, 2] }],
   ["codestral",         { context: 256_000,   maxOutput: 32_000,  thinking: false, tempRange: [0, 2] }],
   // Claude series (Anthropic)
+  ["claude-opus-5",     { context: 1_000_000, maxOutput: 128_000, thinking: false, multimodal: true, cacheMode: "none", format: "anthropic" }],
+  ["claude-sonnet-5",   { context: 1_000_000, maxOutput: 128_000, thinking: false, multimodal: true, cacheMode: "none", format: "anthropic" }],
   ["claude-opus-4",     { context: 200_000,   maxOutput: 32_000,  thinking: false, multimodal: true, cacheMode: "none", format: "anthropic" }],
   ["claude-sonnet-4",   { context: 200_000,   maxOutput: 32_000,  thinking: false, multimodal: true, cacheMode: "none", format: "anthropic" }],
   ["claude-3.5-haiku",  { context: 200_000,   maxOutput: 8_192,   thinking: false, cacheMode: "none", format: "anthropic" }],
   // Gemini series (Google)
+  ["gemini-3-pro",      { context: 1_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, cacheMode: "none", format: "google", noUsageStream: true }],
   ["gemini-2.5-pro",    { context: 2_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, cacheMode: "none", format: "google", noUsageStream: true }],
   ["gemini-2.5-flash",  { context: 1_000_000, maxOutput: 64_000,  thinking: false, multimodal: true, cacheMode: "none", format: "google", noUsageStream: true }],
 ]

package/src/tools/bash.md

@@ -11,6 +11,7 @@ Execute a shell command and return stdout+stderr. Use for running commands, buil
 Parameters:
 - command (required): Shell command to execute
 - timeout: Timeout in milliseconds (default 120000, max ~300000)
+- filter: Optional — a regex; only output lines matching it are returned (case-insensitive). Use instead of hand-writing a pipe into `findstr`/`grep`.
 
 Output format:
 ```

package/src/tools/codemode.mjs

@@ -1,65 +1,123 @@
 /**
  * tools/codemode.mjs — CodeMode: JavaScript execution tool
  *
- * Gives the model an `execute` tool backed by Node.js vm.Script.runInNewContext.
- * Multiple tool calls can be composed into a single script, reducing API round-trips
- * and keeping large intermediate results out of context.
+ * Gives the model an `execute` tool that runs JS in a child `node
+ * --input-type=module --eval` process — NOT the in-process vm sandbox it used
+ * to be. The vm route could not support dynamic `import()` (needs the
+ * --experimental-vm-modules flag) or await it, which pushed every real JS run
+ * back to `bash node -e`. A child node process gives top-level await, dynamic
+ * `import()` of the project's own .mjs modules, native `console`/`fetch`, AND a
+ * killable timeout (an in-process infinite loop would freeze the CLI; a child
+ * process is killed like bash).
  *
- * Sandbox API:
- *   readFile(path)      — read a file relative to cwd, return string
- *   writeFile(path, c)  — write content to a file (auto-creates parent dirs)
- *   glob(pattern)        — return array of matching paths
- *   grep(pattern, file)  — return array of matching lines
- *   log(...args)         — append to output buffer
- *   fetch(url)           — HTTP GET, return string
+ * The child `import()`-s exec-prelude.mjs first for readFile/writeFile/glob/grep/
+ * log/require (paths confined to the workspace root). Full Node via require()/
+ * process/import() is available — same boundary as bash, no fake sandbox.
  *
- * Full Node access via require()/process — no fake sandbox. The bash tool can
- * already reach any Node API, so blocking require here only misled the model
- * about its real capability boundary (project philosophy: no command-level
- * sandbox; transparency + trust + audit).
- *
- * Limits (engineering guards, not security):
- *   timeout: 30s (configurable via timeoutMs param)
- *   maxOutput: 50000 bytes
- *   maxScriptSize: 50000 bytes
- *   file paths confined to cwd (accidental out-of-workspace writes)
+ * Parameters:
+ *   code       — JS to run (top-level await and import() supported)
+ *   workdir    — run in this sub-directory (confined to the workspace)
+ *   filter     — return only output lines matching this regex (case-insensitive)
+ *   timeoutMs  — timeout (default 30s, max 60s)
  */
+import { spawn } from "node:child_process"
+import { dirname, resolve, relative, isAbsolute, sep } from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+import { DESC } from "./shared.mjs"
 
-import { Script, createContext } from "node:vm"
-import { createRequire } from "node:module"
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs"
-import { join, dirname, relative, resolve } from "node:path"
-import { DESC, globToRegex, normalizeEOL } from "./shared.mjs"
-
-const MAX_OUTPUT = 50_000
 const MAX_SCRIPT = 50_000
+const MAX_OUTPUT = 50_000
 const DEFAULT_TIMEOUT = 30_000
 
-/** fetch: only http/https (protocol guard kept; no private-host rejection — the
- *  bash tool can reach anything anyway, so the SSRF check was a fake boundary).
- *  Validation throws SYNCHRONOUSLY so the vm sandbox's try/catch can catch it —
- *  an async throw here would become an unhandled rejection and crash the host process,
- *  and the rejection message would never reach the model. */
-function sandboxFetch(url) {
-  const parsed = new URL(url)
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    throw new Error(`CodeMode fetch: protocol not allowed: ${parsed.protocol}`)
-  }
-  return doFetch(url)
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PRELUDE_URL = pathToFileURL(resolve(__dirname, "exec-prelude.mjs")).href
+
+/** True when `abs` is inside `root` (handles `..` and cross-drive, which
+ *  relative() returns as an absolute path on Windows). */
+function isInside(root, abs) {
+  const rel = relative(root, abs)
+  if (isAbsolute(rel)) return false
+  return rel !== ".." && !rel.startsWith(".." + sep)
+}
+
+/** Resolve workdir relative to cwd, asserting it stays within the workspace. */
+function resolveBaseDir(cwd, workdir) {
+  if (!workdir || typeof workdir !== "string") return cwd
+  const abs = resolve(cwd, workdir)
+  if (!isInside(cwd, abs)) throw new Error(`workdir escapes the workspace: ${workdir}`)
+  return abs
 }
 
-async function doFetch(url) {
-  const ctrl = new AbortController()
-  const timer = setTimeout(() => ctrl.abort(), 10_000)
+/** Keep only output lines matching a regex (execute filter, case-insensitive). */
+function applyFilter(output, filter) {
   try {
-    const res = await fetch(url, { signal: ctrl.signal })
-    const text = await res.text()
-    return text.slice(0, 100_000)
-  } finally {
-    clearTimeout(timer)
+    const re = new RegExp(filter, "i")
+    const lines = output.split("\n").filter((l) => re.test(l))
+    return lines.length ? lines.join("\n") : `(no output lines matched filter "${filter}")`
+  } catch (e) {
+    return `Error: filter regex invalid: ${e.message}`
   }
 }
 
+/** Spawn node, run code + prelude, capture stdout/stderr, enforce timeout/abort.
+ *  Resolves { text, ok } — ok=false on non-zero exit / timeout / abort. */
+function runNodeEval(code, baseDir, root, timeoutMs, signal) {
+  return new Promise((resolvePromise) => {
+    const src = `await import(${JSON.stringify(PRELUDE_URL)});\n${code}`
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", src], {
+      cwd: baseDir,
+      env: { ...process.env, THINCODER_EXEC_ROOT: root },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    })
+
+    let outBuf = "", errBuf = "", truncated = false, settled = false, mode = null
+    let timer = null, kickTimer = null
+
+    const settle = (text, ok) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      clearTimeout(kickTimer)
+      if (signal) signal.removeEventListener("abort", onAbort)
+      resolvePromise({ text, ok })
+    }
+    // SIGKILL (not SIGTERM) so a signal-trapping script can't dodge the watchdog.
+    const kill = () => { try { child.kill("SIGKILL") } catch { /* already gone */ } }
+    // After kill, wait for "close" (child fully reaped) before settling — settling
+    // early races the caller deleting the cwd dir while the child still holds it.
+    const armKick = () => { kickTimer = setTimeout(() => settle(mode === "abort" ? "(stopped)" : `Error: script timed out after ${timeoutMs}ms`, false), 3000) }
+    const onAbort = () => { if (mode) return; mode = "abort"; kill(); armKick() }
+
+    timer = setTimeout(() => { if (!mode) { mode = "timeout"; kill(); armKick() } }, timeoutMs)
+
+    if (signal) {
+      if (signal.aborted) onAbort()
+      else signal.addEventListener("abort", onAbort, { once: true })
+    }
+
+    const cap = (buf, d) => {
+      if (buf.length < MAX_OUTPUT) return buf + d
+      if (!truncated) { truncated = true; return buf + "\n...[output truncated]" }
+      return buf
+    }
+    child.stdout.on("data", (d) => { outBuf = cap(outBuf, d.toString()) })
+    child.stderr.on("data", (d) => { errBuf = cap(errBuf, d.toString()) })
+    child.on("error", (e) => settle(`Error: failed to start node: ${e.message}`, false))
+    child.on("close", (code) => {
+      if (mode === "abort") return settle("(stopped)", false)
+      if (mode === "timeout") return settle(`Error: script timed out after ${timeoutMs}ms`, false)
+      const out = outBuf.trimEnd()
+      const err = errBuf.trim()
+      if (code === 0) {
+        settle(out || "(no output)", true)
+      } else {
+        settle(err ? (out ? `${out}\n\n[stderr]:\n${err}` : err) : `${out}\n(exit code ${code})`.trim(), false)
+      }
+    })
+  })
+}
+
 export const codeModeTool = {
   name: "execute",
   description: DESC("execute"),
@@ -68,10 +126,20 @@ export const codeModeTool = {
     properties: {
       code: {
         type: "string",
-        description: "JavaScript code to execute. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args). require()/process/Node modules are available.",
+        description: "JavaScript code to execute (top-level await and dynamic import() supported). Use provided globals: readFile/writeFile/glob/grep/log, plus native require/process/console/fetch/import.",
+      },
+      workdir: {
+        type: "string",
+        description: "Run in this directory (relative to cwd, confined to the workspace; default cwd)",
+      },
+      filter: {
+        type: "string",
+        description: "Optional: only return output lines matching this regex (case-insensitive)",
       },
       timeoutMs: {
         type: "integer",
+        minimum: 1,
+        maximum: 60000,
         description: `Timeout in milliseconds (default ${DEFAULT_TIMEOUT}, max 60000)`,
       },
     },
@@ -80,97 +148,20 @@ export const codeModeTool = {
   readonly: false,
 
   async execute(args, ctx) {
-    const cwd = ctx.cwd
     const code = args.code ?? ""
-
     if (code.length > MAX_SCRIPT) {
       return `Error: script too large (${code.length} > ${MAX_SCRIPT} bytes). Split into smaller scripts or use individual tools.`
     }
+    let baseDir
+    try { baseDir = resolveBaseDir(ctx.cwd, args.workdir) }
+    catch (e) { return `Error: ${e.message}` }
 
-    const output = []
-    const timeoutMs = Math.min(args.timeoutMs ?? DEFAULT_TIMEOUT, 60_000)
-
-    // File path guard: ensure paths are within cwd (accidental out-of-workspace writes)
-    function safePath(p) {
-      if (typeof p !== "string") throw new Error(`Path must be a string, got ${typeof p}`)
-      const abs = resolve(cwd, p)
-      const rel = relative(cwd, abs)
-      if (rel.startsWith("..") || (rel.includes("..") && process.platform === "win32")) {
-        throw new Error(`Path traversal denied: ${p}`)
-      }
-      return abs
-    }
+    const t = Number(args.timeoutMs)
+    const timeoutMs = Number.isFinite(t) && t > 0 ? Math.min(t, 60_000) : DEFAULT_TIMEOUT
 
-    const sandbox = createContext({
-      readFile: (p) => {
-        const abs = safePath(p)
-        if (!existsSync(abs)) throw new Error(`File not found: ${p}`)
-        const st = statSync(abs)
-        if (st.size > 5_000_000) throw new Error(`File too large: ${p} (${Math.round(st.size / 1000000)}MB)`)
-        return normalizeEOL(readFileSync(abs, "utf8"))
-      },
-      writeFile: (p, content) => {
-        const abs = safePath(p)
-        mkdirSync(dirname(abs), { recursive: true })
-        writeFileSync(abs, String(content), "utf8")
-      },
-      glob: (pattern) => {
-        if (typeof pattern !== "string") throw new Error("glob pattern must be a string")
-        const regex = globToRegex(pattern)
-        const results = []
-        function walk(dir, rel) {
-          let entries
-          try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
-          for (const e of entries) {
-            if (e.name.startsWith(".") || e.name === "node_modules") continue
-            const relPath = rel ? `${rel}/${e.name}` : e.name
-            if (e.isDirectory()) { walk(join(dir, e.name), relPath) }
-            else if (regex.test(relPath)) results.push(relPath)
-          }
-        }
-        walk(cwd, "")
-        return results.slice(0, 200)
-      },
-      grep: (pattern, file) => {
-        if (typeof pattern !== "string") throw new Error("grep pattern must be a string")
-        if (typeof file !== "string") throw new Error("grep file must be a string")
-        const abs = safePath(file)
-        if (!existsSync(abs)) throw new Error(`File not found: ${file}`)
-        const content = normalizeEOL(readFileSync(abs, "utf8"))
-        const regex = new RegExp(pattern)
-        const lines = content.split("\n")
-        const matches = []
-        for (let i = 0; i < lines.length; i++) {
-          if (regex.test(lines[i])) matches.push(`${i + 1}: ${lines[i].slice(0, 200)}`)
-        }
-        return matches.slice(0, 100)
-      },
-      log: (...args) => {
-        const line = args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ")
-        output.push(line)
-        if (output.join("\n").length > MAX_OUTPUT) {
-          output.push("... (output truncated)")
-          throw new Error("CodeMode output limit exceeded")
-        }
-      },
-      fetch: sandboxFetch,
-      // Full Node access — no fake sandbox (bash can reach it anyway).
-      require: createRequire(join(cwd, "__codemode__.js")),
-      process,
-      setTimeout,
-      clearTimeout,
-    })
-
-    try {
-      const script = new Script(code, { filename: "codemode.js" })
-      // timeout belongs on runInContext — the Script constructor ignores it,
-      // so passing it there let runaway scripts (while(true)) hang the process forever.
-      script.runInContext(sandbox, { timeout: timeoutMs })
-      return output.join("\n") || "(no output)"
-    } catch (err) {
-      const out = output.join("\n")
-      const prefix = out ? `${out}\n\n` : ""
-      return `${prefix}Error: ${err.message}`
-    }
+    const { text, ok } = await runNodeEval(code, baseDir, ctx.cwd, timeoutMs, ctx.signal)
+    // Only filter successful output — never swallow an error report behind a filter.
+    if (!ok) return text
+    return args.filter ? applyFilter(text, args.filter) : text
   },
-}
+}

package/src/tools/exec-prelude.mjs

@@ -0,0 +1,84 @@
+/**
+ * exec-prelude.mjs — sandbox API injected into `execute`'s child process.
+ *
+ * The `execute` tool spawns `node --input-type=module --eval` and `import()`-s
+ * this file first, so the user's code gets readFile/writeFile/glob/grep/log/require
+ * without hand-writing fs boilerplate. Confines file paths to the workspace root
+ * (THINCODER_EXEC_ROOT, default cwd) — an orthopedic guard, NOT a sandbox:
+ * require()/process/import()/fetch() are full Node, the same boundary as bash
+ * (project philosophy: no fake sandbox; transparency + audit).
+ */
+import { createRequire } from "node:module"
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, readdirSync } from "node:fs"
+import { resolve, relative, dirname, join, isAbsolute, sep } from "node:path"
+
+const require = createRequire(join(process.cwd(), "__exec__.js"))
+const root = process.env.THINCODER_EXEC_ROOT || process.cwd()
+
+/** Resolve a path against the working dir, asserting it stays within the workspace root. */
+function safe(p) {
+  if (typeof p !== "string") throw new Error(`Path must be a string, got ${typeof p}`)
+  const abs = resolve(process.cwd(), p)
+  const rel = relative(root, abs)
+  // isAbsolute(rel) covers cross-drive (relative() returns an absolute path then)
+  if (isAbsolute(rel) || rel === ".." || rel.startsWith(".." + sep)) {
+    throw new Error(`Path traversal denied: ${p}`)
+  }
+  return abs
+}
+
+function globToRegex(pattern) {
+  const DS = "\u0001", DP = "\u0002"
+  const escaped = pattern
+    .replace(/\*\*\//g, DS).replace(/\*\*/g, DP)
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")
+    .replace(new RegExp(DS, "g"), "(?:.+/)?").replace(new RegExp(DP, "g"), ".*")
+  return new RegExp(`^${escaped}$`)
+}
+
+globalThis.require = require
+globalThis.readFile = (p) => {
+  const abs = safe(p)
+  if (!existsSync(abs)) throw new Error(`File not found: ${p}`)
+  if (statSync(abs).size > 5_000_000) throw new Error(`File too large: ${p}`)
+  return readFileSync(abs, "utf8").replace(/\r\n/g, "\n")
+}
+globalThis.writeFile = (p, content) => {
+  const abs = safe(p)
+  mkdirSync(dirname(abs), { recursive: true })
+  writeFileSync(abs, String(content), "utf8")
+}
+globalThis.glob = (pattern) => {
+  if (typeof pattern !== "string") throw new Error("glob pattern must be a string")
+  const re = globToRegex(pattern)
+  const out = []
+  function walk(dir, rel) {
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      if (e.name.startsWith(".") || e.name === "node_modules") continue
+      const rp = rel ? `${rel}/${e.name}` : e.name
+      if (e.isDirectory()) walk(join(dir, e.name), rp)
+      else if (re.test(rp)) out.push(rp)
+    }
+  }
+  walk(process.cwd(), "")
+  const capped = out.slice(0, 200)
+  if (out.length > 200) capped.push(`... (${out.length - 200} more)`)
+  return capped
+}
+globalThis.grep = (pattern, file) => {
+  if (typeof pattern !== "string") throw new Error("grep pattern must be a string")
+  if (typeof file !== "string") throw new Error("grep file must be a string")
+  const abs = safe(file)
+  if (!existsSync(abs)) throw new Error(`File not found: ${file}`)
+  const re = new RegExp(pattern)
+  const lines = readFileSync(abs, "utf8").replace(/\r\n/g, "\n").split("\n")
+  const m = []
+  for (let i = 0; i < lines.length; i++) if (re.test(lines[i])) m.push(`${i + 1}: ${lines[i].slice(0, 200)}`)
+  const capped = m.slice(0, 100)
+  if (m.length > 100) capped.push(`... (${m.length - 100} more)`)
+  return capped
+}
+globalThis.log = (...a) => console.log(a.map((x) => (x && typeof x === "object" ? JSON.stringify(x) : String(x))).join(" "))

package/src/tools/execute.md

@@ -1,5 +1,17 @@
-Execute JavaScript code with full Node access. Use this to compose multiple file operations into one call — read, write, glob, grep, log, or require() any module. Max 30s timeout, 50KB output.
+Execute JavaScript code with full Node access. Runs in a real `node` process with top-level `await` and dynamic `import()` — so you can load and call the project's own `.mjs` modules directly. Use this to compose multiple operations into one call — read, write, glob, grep, log, import, or require() — without shelling out to `bash node -e`.
+
+**Route to execute instead of bash:**
+- `node -e "…"` → execute (top-level await + import() + console all work)
 
 Parameters:
-- code (required): JavaScript code to execute. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args). require()/process/Node modules are available.
+- code (required): JavaScript to run. Top-level `await` and `import('./x.mjs')` are supported. Globals: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args) — plus native require/process/console/fetch/import.
+- workdir: run in this directory (relative to cwd, confined to the workspace; default cwd)
+- filter: optional — only return output lines matching this regex (case-insensitive)
 - timeoutMs: Timeout in milliseconds (default 30000, max 60000)
+
+Notes:
+- `console.log(...)` and `log(...)` both print to the result; objects are JSON-stringified by `log`.
+- File paths are confined to the workspace root (`..` traversal is denied) — but `require`/`process`/`import()` are full Node, same boundary as bash.
+- A non-zero exit / thrown exception returns the stderr (error + stack) as the result.
+- Output capped at ~50KB; use `writeFile` to a file if you need more.
+- Use `write`/`edit`/`apply_patch` for source edits and `bash` for subprocess/CLI runs (`npm test`, `node --test`, servers) — execute is for in-process JS, not spawning programs.

package/src/tools/file_ops.md

@@ -0,0 +1,16 @@
+Move, copy, or rename a file/directory.
+
+**Route to file_ops instead of bash:**
+- `mv a b` → file_ops action=move
+- `cp a b` / `copy` → file_ops action=copy
+- `ren a b` / `rename a b` → file_ops action=rename
+
+Parameters:
+- action (required): move | copy | rename
+- source (required): source path, relative to cwd or absolute
+- dest (required): destination path
+
+Notes:
+- Paths are confined to the working directory (same safety as write/edit) — bash has NO directory confinement.
+- `dest` is overwritten if it already exists. `copy` is recursive for directories.
+- To create a directory, use `write` (creates parent dirs) or `bash mkdir`.

package/src/tools/get_current_time.md

@@ -0,0 +1,6 @@
+Get the current date, time, weekday, and timezone.
+
+**Route to get_current_time instead of bash:**
+- `date` / `time` → get_current_time
+
+Use it whenever a task depends on the current time or date (deadlines, freshness, timestamps) rather than shelling out.

package/src/tools/git.md

@@ -2,14 +2,20 @@ Run a git command. Use this to see uncommitted changes, staged changes, diff aga
 - action='diff': Show unified diff — what changed since last commit. Set staged=true for staged-only diff, ref=<ref> to compare against a specific commit/branch, path=<dir> to scope to a file or directory.
 - action='status': Show working tree state — staged, unstaged, untracked files, and conflicts. Returns categorized lists.
 - action='log': Show recent commit history. Set count to limit, oneline=true for compact format, path=<file> to see history of one file.
+- action='show': Show a commit's details (--stat). Set ref=<ref> to inspect a specific commit (default HEAD).
 - action='checkpoint': Manage git-based snapshots. Use checkpointAction to choose: list (overview), create (snapshot now), rewind (restore snapshot by id), cat (read a file from a snapshot).
+- action='rm': Untrack a file/directory (git rm --cached — keeps the file on disk). path is required.
+- action='commit': Stage all changes and commit. message is required. Confirms with the user (outward action).
+- action='push': Push the current branch to the remote. Confirms with the user (outward action).
 
 Parameters:
-- action (required): diff / status / log / checkpoint
+- action (required): diff / status / log / show / checkpoint / rm / commit / push
 - staged: (diff) Show staged changes instead of working tree
-- path: (diff/log/checkpoint:cat/checkpoint:rewind) File or directory to scope to
-- ref: (diff) Compare against this ref (default HEAD)
+- path: (diff/log/checkpoint:cat/checkpoint:rewind/rm) File or directory to scope to
+- ref: (show) Commit ref to inspect (default HEAD)
 - count: (log) Number of commits (default 10)
 - oneline: (log) One-line-per-commit format
+- message: (commit) Commit message — required for commit
+- filter: Optional — keep only status/diff/log output lines matching this regex (case-insensitive)
 - checkpointAction: (checkpoint) list snapshots / create one / restore by id / read file from snapshot
-- checkpointId: (checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)
+- checkpointId: (checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)

package/src/tools/git.mjs

@@ -7,19 +7,44 @@ import { escapeXml } from "../agent/helpers.mjs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 
+/** Keep only output lines matching a regex (git filter, case-insensitive). */
+function filterLines(output, filter) {
+  if (!filter) return output
+  try {
+    const re = new RegExp(filter, "i")
+    const lines = output.split("\n").filter((l) => re.test(l))
+    return lines.length ? lines.join("\n") : `(no lines matched filter "${filter}")`
+  } catch (e) {
+    return `Error: filter regex invalid: ${e.message}`
+  }
+}
+
+/** Run git and report failure (stderr + exit code) instead of swallowing it.
+ *  Used by write ops (commit/push/rm) where a silent "" would masquerade as success. */
+function runGitStrict(cwd, cmdArgs) {
+  try {
+    const out = execFileSync("git", cmdArgs, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim().replace(/\r/g, "")
+    return { ok: true, out }
+  } catch (e) {
+    return { ok: false, out: String(e.stdout || "").trim(), err: String(e.stderr || e.message || "").trim() }
+  }
+}
+
 export const gitTool = {
   name: "git",
   description: DESC("git"),
   parameters: {
     type: "object",
     properties: {
-      action: { type: "string", enum: ["diff", "status", "log", "checkpoint"], description: "diff / status / log / checkpoint" },
+      action: { type: "string", enum: ["diff", "status", "log", "show", "checkpoint", "rm", "commit", "push"], description: "diff / status / log / show / checkpoint / rm / commit / push" },
       // diff/log params
       staged: { type: "boolean", description: "(diff) Show staged changes instead of working tree" },
-      path: { type: "string", description: "(diff/log/checkpoint:cat/versions/rewind) File or directory to scope to" },
-      ref: { type: "string", description: "(diff) Compare against this ref (default HEAD)" },
+      path: { type: "string", description: "(diff/log/checkpoint:cat/versions/rewind/rm) File or directory to scope to" },
+      ref: { type: "string", description: "(show) Commit ref to show (default HEAD)" },
       count: { type: "number", description: "(log) Number of commits (default 10)" },
       oneline: { type: "boolean", description: "(log) One-line-per-commit format" },
+      message: { type: "string", description: "(commit) Commit message — required for commit" },
+      filter: { type: "string", description: "Optional: keep only status/diff/log output lines matching this regex (case-insensitive)" },
       // checkpoint params
       checkpointAction: { type: "string", enum: ["list", "create", "rewind", "cat", "versions"], description: "(checkpoint) list snapshots / create one / restore by id / read file from snapshot / list a file's historical versions" },
       checkpointId: { type: "string", description: "(checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)" },
@@ -35,7 +60,7 @@ export const gitTool = {
         const flags = args.staged ? ["--staged"] : []
         const paths = args.path ? [args.path] : []
         const out = runGit(ctx.cwd, ["diff", ...flags, ref, "--", ...paths])
-        return truncate(out || "(no changes)")
+        return truncate(filterLines(out || "(no changes)", args.filter))
       }
       case "status": {
         const porcelain = runGit(ctx.cwd, ["status", "--porcelain"])
@@ -68,17 +93,44 @@ export const gitTool = {
         if (unstaged.length) parts.push("Unstaged (" + unstaged.length + "):\n" + unstaged.join("\n"))
         if (untracked.length) parts.push("Untracked (" + untracked.length + "):\n" + untracked.join("\n"))
         if (conflicts.length) parts.push("Conflicts (" + conflicts.length + "):\n" + conflicts.join("\n"))
-        return truncate(parts.join("\n\n"))
+        return truncate(filterLines(parts.join("\n\n"), args.filter))
       }
       case "log": {
-        const n = Math.min(Math.max(1, args.count ?? 10), 200)
+        const parsed = Number.parseInt(args.count, 10)
+        const n = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 10
         const isOneline = args.oneline
         const cmdArgs = isOneline
           ? ["log", "-" + n, "--oneline"]
           : ["log", "-" + n, "--format=%h %ad %an %s", "--date=short"]
         if (args.path) cmdArgs.push("--", args.path)
         const out = runGit(ctx.cwd, cmdArgs)
-        return truncate(out || "(no commits)")
+        return truncate(filterLines(out || "(no commits)", args.filter))
+      }
+      case "show": {
+        const ref = args.ref ?? "HEAD"
+        if (!/^[A-Za-z0-9._\/~^@][A-Za-z0-9._\/~^@{}\-]*$/.test(ref)) throw new Error(`Invalid git ref: ${ref}`)
+        const out = runGit(ctx.cwd, ["show", "--stat", ref])
+        return truncate(out || "(no such commit)")
+      }
+      case "rm": {
+        if (!args.path) return "Error: rm requires path (the file/directory to untrack, relative to repo root)"
+        const r = runGitStrict(ctx.cwd, ["rm", "--cached", "-r", "--", args.path])
+        return r.ok ? truncate(r.out || `Untracked ${args.path} (kept on disk)`) : truncate(`git rm failed: ${r.err || r.out}`)
+      }
+      case "commit": {
+        if (!args.message) return "Error: commit requires message"
+        const add = runGitStrict(ctx.cwd, ["add", "-A"])
+        if (!add.ok) return truncate(`git add failed: ${add.err || add.out || "(no output)"}`)
+        const commit = runGitStrict(ctx.cwd, ["commit", "-m", args.message])
+        const parts = []
+        if (add.out) parts.push(add.out)
+        if (commit.ok) { if (commit.out) parts.push(commit.out) }
+        else parts.push(`git commit failed: ${commit.err || "(no output)"}`)
+        return truncate(parts.join("\n") || "(commit produced no output)")
+      }
+      case "push": {
+        const r = runGitStrict(ctx.cwd, ["push"])
+        return r.ok ? truncate(r.out || "(push complete — no output)") : truncate(`git push failed: ${r.err || r.out || "(no output)"}`)
       }
       case "checkpoint": {
         const { createCheckpoint, listCheckpoints, rewind, listFileVersions, isGitRepo } = await import("../git/checkpoint.mjs")
@@ -139,7 +191,7 @@ export const gitTool = {
         throw new Error(`Unknown checkpoint action: ${sub}. Use: list | create | rewind | cat | versions`)
       }
       default:
-        return `Unknown action '${args.action}'. Use: diff | status | log | checkpoint`
+        return `Unknown action '${args.action}'. Use: diff | status | log | show | checkpoint | rm | commit | push`
     }
   },
 }

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)
+    }
+  }
+}