thincoder 0.12.36 → 0.12.38

package/src/session.mjs

@@ -13,6 +13,7 @@ import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsS
 import { join, dirname } from "node:path"
 import { execSync } from "node:child_process"
 import { configDir } from "./config.mjs"
+import { migrateHashLength } from "./session-migrate.mjs"
 
 let currentSessionId = null
 
@@ -35,40 +36,6 @@ function cwdHash(cwd) {
   return createHash("sha1").update(normalizeCwd(cwd)).digest("hex")
 }
 
-/** One-time migration: rename legacy short-hash session files to the full 40-char hash.
- *  Idempotent; runs on first access per cwd.
- *  Historical hash algorithms (all sha1, none normalized the drive letter):
- *    - CLI:      sha1(cwd).slice(0, 12)      — cwd comes from process.cwd() (uppercase drive on Windows)
- *    - VS Code:  sha1(cwd).slice(0, 16)      — cwd comes from uri.fsPath (LOWERCASE drive on Windows)
- *  Plus the previous migration attempt's assumption (normalized 12 = first 12 of the full hash).
- *  Every combination is tried — a migration that only checks one candidate misses real
- *  legacy files (drive-letter case differs between CLI and VS Code historical paths). */
-function migrateHashLength(cwd, fullHash) {
-  const dir = join(configDir, "sessions")
-  const lower = cwd.replace(/^([A-Z]):/, (_, d) => d.toLowerCase() + ":")
-  const candidates = [
-    createHash("sha1").update(cwd).digest("hex").slice(0, 12),
-    createHash("sha1").update(cwd).digest("hex").slice(0, 16),
-    createHash("sha1").update(lower).digest("hex").slice(0, 12),
-    createHash("sha1").update(lower).digest("hex").slice(0, 16),
-    fullHash.slice(0, 12),
-  ]
-  const newBase = join(dir, `${fullHash}.json`)
-  let migrated = false
-  for (const short of new Set(candidates)) {
-    const legacyBase = join(dir, `${short}.json`)
-    if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) continue
-    migrated = true
-    try {
-      for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
-        const from = legacyBase + suffix
-        if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
-      }
-    } catch { /* best-effort; leave files in place on failure */ }
-  }
-  return migrated
-}
-
 /** Derive base session path from cwd hash. Migrates legacy short-hash files on first access. */
 export function sessionPath(cwd) {
   const hash = cwdHash(cwd)
@@ -149,10 +116,6 @@ function saveManifest(cwd, m) {
   writeSessionFile(manifestPath(cwd), m)
 }
 
-/**
- * Ensure an active slot exists in the manifest, migrating legacy data if needed.
- * Called by activeSlot() — idempotent, safe to call repeatedly.
- */
 /**
  * Claim a slot for this process and set it as active. Idempotent.
  * Preference order:

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`
     }
   },
 }