thincoder 0.12.52 → 0.12.54

package/src/tools/git.mjs

@@ -3,49 +3,25 @@ import {
   truncate,
   runGit
 } from "./shared.mjs";
-import { escapeXml } from "../agent/helpers.mjs";
 import { execFileSync } from "node:child_process";
-import { join, resolve, relative, isAbsolute, sep } from "node:path";
+import { resolve, relative, isAbsolute, sep } from "node:path";
+import { filterLines, runGitStrict, validateRef, gitConfigArgs, snapshotBefore, executeExtAction } from "./git-ext.mjs";
+import { executeCheckpointAction } from "./git-checkpoint.mjs";
 
-/** 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 PRESERVING per-line leading whitespace. runGit trims the WHOLE output, which
  *  strips a porcelain line's leading " " (the unstaged marker) and misclassifies an
  *  unstaged-only first line as staged. status uses this so the staged/unstaged column survives. */
-function runGitRaw(cwd, cmdArgs) {
+function runGitRaw(cwd, cmdArgs, config = []) {
   try {
-    return execFileSync("git", cmdArgs, { cwd, encoding: "utf8", maxBuffer: 10 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).replace(/\r/g, "").replace(/\n$/, "")
+    return execFileSync("git", [...config, ...cmdArgs], { cwd, encoding: "utf8", maxBuffer: 10 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).replace(/\r/g, "").replace(/\n$/, "")
   } catch (e) {
     return String(e.stdout || "").replace(/\r/g, "")
   }
 }
 
-/** 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() }
-  }
-}
 
-/** Validate a git ref / branch / tag / remote name (no option injection, no whitespace). */
-function validateRef(ref, what = "git ref") {
-  if (!/^[A-Za-z0-9._/~^@][A-Za-z0-9._/~^@{}-]*$/.test(ref)) throw new Error(`Invalid ${what}: ${ref}`)
-  return ref
-}
+
 
 /** True when `abs` is inside `root` (handles `..` and cross-drive, which relative()
  *  returns as an absolute path on Windows). */
@@ -63,19 +39,7 @@ function resolveBaseDir(cwd, workdir) {
   return abs
 }
 
-/** Snapshot the working tree before a destructive op (reset --hard / checkout file / restore /
- *  stash pop / branch|tag delete). Best-effort — a snapshot failure must not block the op
- *  (the approval/permission layer is the real gate). Returns a note line or "". */
-async function snapshotBefore(ctx, label) {
-  try {
-    const { createCheckpoint, isGitRepo } = await import("../git/checkpoint.mjs")
-    if (!isGitRepo(ctx.cwd)) return ""
-    const cp = await createCheckpoint(ctx.cwd)
-    return `[snapshot ${cp.id} created before ${label}]\n`
-  } catch {
-    return ""
-  }
-}
+
 
 export const gitTool = {
   name: "git",
@@ -83,11 +47,11 @@ export const gitTool = {
   parameters: {
     type: "object",
     properties: {
-      action: { type: "string", enum: ["diff", "status", "log", "show", "checkpoint", "add", "rm", "commit", "push", "tag", "branch", "checkout", "restore", "stash", "fetch", "pull", "reset", "revert", "merge", "cherry-pick"], description: "diff / status / log / show / checkpoint / add / rm / commit / push / tag / branch / checkout / restore / stash / fetch / pull / reset / revert / merge / cherry-pick" },
+      action: { type: "string", enum: ["diff", "status", "log", "show", "checkpoint", "add", "rm", "commit", "push", "tag", "branch", "checkout", "restore", "stash", "fetch", "pull", "reset", "revert", "merge", "cherry-pick", "ls-remote", "clone", "init", "rebase", "remote", "clean", "switch", "apply", "worktree", "archive", "blame", "mv"], description: "diff / status / log / show / checkpoint / add / rm / commit / push / tag / branch / checkout / restore / stash / fetch / pull / reset / revert / merge / cherry-pick / ls-remote / clone / init / rebase / remote / clean / switch / apply / worktree / archive / blame / mv — clean/rebase 操作前自动快照，checkpointAction=rewind 恢复" },
       // diff/log params
       staged: { type: "boolean", description: "(diff) Show staged changes instead of working tree" },
-      path: { type: "string", description: "(diff/log/add/commit/checkout/restore/checkpoint:cat/versions/rewind/rm) File or directory to scope to / stage / restore" },
-      ref: { type: "string", description: "(show/diff/checkout/reset/revert/merge/cherry-pick/tag:create/branch:create) Commit/branch/ref; (push/pull/fetch) the branch or tag to push/pull/fetch (space-separated for multiple)" },
+      path: { type: "string", description: "(diff/log/add/commit/checkout/restore/checkpoint:cat/versions/rewind/rm/apply/archive/blame/mv/worktree) File or directory to scope to / stage / restore（checkout/restore 操作前自动快照，checkpointAction=rewind 恢复）" },
+      ref: { type: "string", description: "(diff/show/checkout/reset/revert/merge/cherry-pick/tag:create/branch:create/rebase/worktree:add/archive) Commit/branch/ref; (push/pull/fetch) the branch or tag (space-separated for multiple)" },
       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; (stash:push) stash message" },
@@ -96,14 +60,23 @@ export const gitTool = {
       name: { type: "string", description: "(branch/tag) The branch or tag name (create/delete/switch)" },
       remote: { type: "string", description: "(push/fetch/pull) Remote name (e.g. origin). Default: current upstream" },
       workdir: { type: "string", description: "Run git in this workspace subdirectory (monorepo / multi-repo). Confined to the workspace. Default: cwd" },
+      config: { type: "array", items: { type: "string" }, description: "(network actions: push/fetch/pull/ls-remote) git -c overrides, e.g. [\"http.proxy=http://10.2.2.112:3128\"] for blocked remotes" },
       tags: { type: "boolean", description: "(push) Also push all tags (--tags)" },
-      mode: { type: "string", enum: ["soft", "mixed", "hard"], description: "(reset) reset mode — hard snapshots the tree first + needs confirmation" },
-      tagAction: { type: "string", enum: ["list", "create", "delete"], description: "(tag) list tags / create one / delete one" },
-      branchAction: { type: "string", enum: ["list", "create", "delete", "switch"], description: "(branch) list branches / create / delete / switch to one" },
-      stashAction: { type: "string", enum: ["push", "pop", "list"], description: "(stash) push (stash now) / pop (apply+drop) / list" },
+      mode: { type: "string", enum: ["soft", "mixed", "hard"], description: "(reset) reset mode — hard snapshots the tree first + needs confirmation（操作前自动快照，checkpointAction=rewind 恢复）" },
+      tagAction: { type: "string", enum: ["list", "create", "delete"], description: "(tag) list tags / create one / delete one（delete 操作前自动快照，checkpointAction=rewind 恢复）" },
+      branchAction: { type: "string", enum: ["list", "create", "delete", "switch"], description: "(branch) list branches / create / delete / switch to one（delete 操作前自动快照，checkpointAction=rewind 恢复）" },
+      stashAction: { type: "string", enum: ["push", "pop", "list"], description: "(stash) push (stash now) / pop (apply+drop) / list（pop 操作前自动快照，checkpointAction=rewind 恢复）" },
       // 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" },
+      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（rewind 可恢复操作前状态，恢复前自动快照可逆）" },
       checkpointId: { type: "string", description: "(checkpoint) Snapshot id — required for rewind and cat; optional for list (shows file tree)" },
+      // F7 new-action params
+      remoteAction: { type: "string", enum: ["list", "add", "remove", "set-url"], description: "(remote) list remotes / add / remove / set-url" },
+      remoteUrl: { type: "string", description: "(remote add/set-url) Remote URL (https/git/ssh or local path)" },
+      rebaseAction: { type: "string", enum: ["start", "abort", "continue"], description: "(rebase) start (ref required) / abort / continue（操作前自动快照，checkpointAction=rewind 恢复）" },
+      dryRun: { type: "boolean", description: "(clean) preview only (-n) — no deletion, no snapshot; real clean 操作前自动快照，checkpointAction=rewind 恢复" },
+      create: { type: "boolean", description: "(switch) create the branch then switch (-c)" },
+      dest: { type: "string", description: "(mv) destination path (file or directory)" },
+      worktreeAction: { type: "string", enum: ["list", "add", "remove"], description: "(worktree) list / add (path, ref) / remove (path)" },
     },
     required: ["action"],
   },
@@ -112,6 +85,9 @@ export const gitTool = {
     // workdir: run git in a workspace subdirectory (monorepo / multi-repo). Shadow ctx.cwd so
     // every action + snapshotBefore + checkpoint resolves against the workdir, confined to the workspace.
     if (args.workdir) ctx = { ...ctx, cwd: resolveBaseDir(ctx.cwd, args.workdir) }
+    // git -c overrides (proxy etc.) — only network actions need them; passing to every
+    // action would be harmless but noisy. cfgArgs stays [] for local ops.
+    const cfgArgs = gitConfigArgs(args.config)
     switch (args.action) {
       case "diff": {
         const ref = args.ref ?? "HEAD"
@@ -186,7 +162,18 @@ export const gitTool = {
         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) }
+        if (commit.ok) {
+          if (commit.out) parts.push(commit.out)
+          // F6: commit = new safety baseline — clear this project's checkpoints
+          // (best-effort per NF7: a failed cleanup never blocks the commit result).
+          try {
+            const { deleteCheckpointsForCwd } = await import("../git/checkpoint.mjs")
+            await deleteCheckpointsForCwd(ctx.cwd)
+            parts.push("(checkpoints cleared — commit is a new safety baseline)")
+          } catch (e) {
+            parts.push(`(checkpoint cleanup skipped: ${e.message})`)
+          }
+        }
         else parts.push(`git commit failed: ${commit.err || "(no output)"}`)
         return truncate(parts.join("\n") || "(commit produced no output)")
       }
@@ -195,9 +182,19 @@ export const gitTool = {
         if (args.remote) cmdArgs.push(validateRef(args.remote, "remote"))
         if (args.ref) for (const r of args.ref.split(/\s+/).filter(Boolean)) cmdArgs.push(validateRef(r, "ref"))
         if (args.tags) cmdArgs.push("--tags")
-        const r = runGitStrict(ctx.cwd, cmdArgs)
+        const r = runGitStrict(ctx.cwd, cmdArgs, cfgArgs)
         return r.ok ? truncate(r.out || "(push complete — no output)") : truncate(`git push failed: ${r.err || r.out || "(no output)"}`)
       }
+      case "ls-remote": {
+        // Lightweight remote-ref check (which refs a remote has) — network action,
+        // read-only, no snapshot. Config plumbing for blocked/gated remotes.
+        const cmdArgs = ["ls-remote"]
+        if (args.remote) cmdArgs.push(validateRef(args.remote, "remote"))
+        if (args.ref) for (const r of args.ref.split(/\s+/).filter(Boolean)) cmdArgs.push(validateRef(r, "ref"))
+        const out = runGit(ctx.cwd, cmdArgs, cfgArgs)
+        if (!out) return "(no refs / remote unreachable)"
+        return truncate(filterLines(out, args.filter))
+      }
       case "add": {
         // Granular staging: stage `path` when given, else all changes (add -A).
         const cmdArgs = args.path ? ["add", "--", args.path] : ["add", "-A"]
@@ -293,14 +290,14 @@ export const gitTool = {
         const cmdArgs = ["fetch"]
         if (args.remote) cmdArgs.push(validateRef(args.remote, "remote"))
         if (args.ref) cmdArgs.push(validateRef(args.ref, "ref"))
-        const r = runGitStrict(ctx.cwd, cmdArgs)
+        const r = runGitStrict(ctx.cwd, cmdArgs, cfgArgs)
         return r.ok ? truncate(r.out || "(fetch complete — no output)") : truncate(`git fetch failed: ${r.err || r.out}`)
       }
       case "pull": {
         const cmdArgs = ["pull"]
         if (args.remote) cmdArgs.push(validateRef(args.remote, "remote"))
         if (args.ref) cmdArgs.push(validateRef(args.ref, "ref"))
-        const r = runGitStrict(ctx.cwd, cmdArgs)
+        const r = runGitStrict(ctx.cwd, cmdArgs, cfgArgs)
         return r.ok ? truncate(r.out || "(pull complete — no output)") : truncate(`git pull failed: ${r.err || r.out}`)
       }
       case "reset": {
@@ -330,66 +327,24 @@ export const gitTool = {
         const r = runGitStrict(ctx.cwd, ["cherry-pick", args.ref])
         return r.ok ? truncate(r.out || `Cherry-picked ${args.ref}`) : truncate(`git cherry-pick failed: ${r.err || r.out}`)
       }
-      case "checkpoint": {
-        const { createCheckpoint, listCheckpoints, rewind, listFileVersions, isGitRepo } = await import("../git/checkpoint.mjs")
-        if (!isGitRepo(ctx.cwd)) throw new Error("Not a git repository — checkpoints unavailable")
-
-        const sub = args.checkpointAction
-        if (!sub) return "checkpoint: missing checkpointAction — use: list | create | rewind | cat | versions"
+      // F7 扩展 action + checkpoint：实现拆在 git-ext.mjs / git-checkpoint.mjs（500 行硬限）
+      case "clone":
+      case "init":
+      case "rebase":
+      case "remote":
+      case "clean":
+      case "switch":
+      case "apply":
+      case "worktree":
+      case "archive":
+      case "blame":
+      case "mv":
+        return executeExtAction(args, ctx)
+      case "checkpoint":
+        return executeCheckpointAction(args, ctx)
 
-        if (sub === "create") {
-          const cp = await createCheckpoint(ctx.cwd)
-          return `Checkpoint ${cp.id} created (${cp.files} file(s): ${cp.tracked.length} tracked, ${cp.untracked.length} untracked)`
-        }
-        if (sub === "versions") {
-          if (!args.path) throw new Error("path is required for versions — the file whose history you want")
-          const versions = await listFileVersions(ctx.cwd, args.path)
-          if (versions.length === 0) return `No snapshot copies of "${args.path}" found (it was never part of an auto/protection snapshot).`
-          return (
-            `Historical versions of "${args.path}" (${versions.length}, newest first):\n` +
-            versions.map((v) =>
-              `  ${v.snapshotId}  ${new Date(v.time).toISOString()}  ${v.size}B  sha:${v.sha}  (${v.source})` +
-              (v.sha === versions[versions.indexOf(v) - 1]?.sha ? "  ← same content as previous" : "")
-            ).join("\n") +
-            `\nRestore a version: checkpointAction=rewind checkpointId=<snapshotId> path="${args.path}"`
-          )
-        }
-        if (sub === "rewind") {
-          if (!args.checkpointId) throw new Error("checkpointId is required for rewind — use checkpointAction=list to see snapshot ids")
-          if (!args.path) throw new Error("path is required for rewind — full restore is disabled (as dangerous as `git checkout -- .`). Restore files individually. Use checkpointAction=versions path=<file> to list a file's historical versions.")
-          const s = await rewind(ctx.cwd, args.checkpointId, { path: args.path })
-          return `Restored "${args.path}" (${s.type}) from checkpoint ${args.checkpointId}.\n(The pre-restore state was snapshotted first — you can restore again to go back.)`
-        }
-        if (sub === "cat") {
-          if (!args.checkpointId) throw new Error("checkpointId is required for cat — use checkpointAction=list to see snapshot ids")
-          if (!args.path) throw new Error("path is required for cat — specify which file to read")
-          const { catFile } = await import("../git/checkpoint.mjs")
-          return await catFile(ctx.cwd, args.checkpointId, args.path)
-        }
-        if (sub === "list") {
-          const cps = await listCheckpoints(ctx.cwd)
-          if (cps.length === 0) return "(no checkpoints yet)"
-
-          // Specific id: show the file tree within that snapshot
-          if (args.checkpointId) {
-            const cp = cps.find((c) => c.id === args.checkpointId)
-            if (!cp) throw new Error(`checkpoint ${args.checkpointId} not found`)
-            return formatFileTree(cp)
-          }
-
-          // Overview: list of all snapshots (file names are XML-escaped: they are
-          // untrusted input that flows back into the model's context)
-          return cps.map((c) => {
-            const parts = [`${c.id}  ${new Date(c.time).toISOString()}`]
-            if (c.tracked.length) parts.push(`${c.tracked.length} tracked: ${c.tracked.map(escapeXml).join(", ")}`)
-            if (c.untracked.length) parts.push(`${c.untracked.length} untracked: ${c.untracked.map(escapeXml).join(", ")}`)
-            return parts.join("  ")
-          }).join("\n")
-        }
-        throw new Error(`Unknown checkpoint action: ${sub}. Use: list | create | rewind | cat | versions`)
-      }
       default:
-        return `Unknown action '${args.action}'. Use: diff | status | log | show | checkpoint | add | rm | commit | push | tag | branch | checkout | restore | stash | fetch | pull | reset | revert | merge | cherry-pick`
+        return `Unknown action '${args.action}'. Use: diff | status | log | show | checkpoint | add | rm | commit | push | tag | branch | checkout | restore | stash | fetch | pull | reset | revert | merge | cherry-pick | ls-remote | clone | init | rebase | remote | clean | switch | apply | worktree | archive | blame | mv`
     }
   },
 }
@@ -418,45 +373,3 @@ export const questionTool = {
   },
 }
 
-/** Format a checkpoint's file list as a directory tree (directories first, indented display) */
-function formatFileTree(cp) {
-  // File names are XML-escaped: untrusted input that flows back into the model's context
-  const all = [
-    ...(cp.tracked ?? []).map((f) => ({ path: escapeXml(f), type: "" })),
-    ...(cp.untracked ?? []).map((f) => ({ path: escapeXml(f), type: " (untracked)" })),
-  ]
-  if (all.length === 0) return "(empty checkpoint)"
-
-  all.sort((a, b) => a.path.localeCompare(b.path))
-
-  const tree = new Map()
-  for (const { path, type } of all) {
-    const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "."
-    if (!tree.has(dir)) tree.set(dir, [])
-    tree.get(dir).push({ name: path.slice(dir === "." ? 0 : dir.length + 1), type })
-  }
-
-  const lines = []
-  const dirs = [...tree.keys()].sort()
-  for (const dir of dirs) {
-    if (dir !== "." && !lines.includes(dir + "/")) {
-      const parts = dir.split("/")
-      for (let i = 1; i <= parts.length; i++) {
-        const prefix = parts.slice(0, i).join("/") + "/"
-        if (!lines.includes(prefix)) lines.push(prefix)
-      }
-    }
-  }
-  for (const dir of dirs) {
-    if (dir !== ".") {
-      for (const { name, type } of tree.get(dir)) {
-        lines.push(`  ${dir}/${name}${type}`)
-      }
-    }
-  }
-  for (const { name, type } of tree.get(".") ?? []) {
-    lines.push(name + type)
-  }
-
-  return lines.join("\n")
-}

package/src/tools/shared.mjs

@@ -447,10 +447,12 @@ export function htmlToText(html) {
     .trim()
 }
 
-/** Execute a git command. maxBuffer 10MB prevents large diff/log overflow; on overflow, returns truncated partial output rather than empty. */
-export function runGit(cwd, cmdArgs) {
+/** Execute a git command. maxBuffer 10MB prevents large diff/log overflow; on overflow, returns truncated partial output rather than empty.
+ *  config: optional array of `-c key=value` overrides (e.g. ["http.proxy=http://10.2.2.112:3128"]) —
+ *  inserted verbatim after `git`, so network actions (push/fetch/pull/ls-remote) can route through a proxy. */
+export function runGit(cwd, cmdArgs, config = []) {
   try {
-    return execFileSync("git", cmdArgs, { cwd, encoding: "utf8", maxBuffer: 10 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).trim().replace(/\r/g, "")
+    return execFileSync("git", [...config, ...cmdArgs], { cwd, encoding: "utf8", maxBuffer: 10 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).trim().replace(/\r/g, "")
   } catch (e) {
     // maxBuffer overflow: e.stdout contains partial collected output — return it
     // (callers show "(truncated)"-style tails). ALL OTHER errors (non-git repo,

package/src/tools/system.mjs

@@ -31,6 +31,22 @@ function applyLineFilter(output, filter) {
   return truncate(lines.join("\n"))
 }
 
+/** POSIX-only constructs that cmd.exe reads literally (and thus breaks). Detected
+ *  so the agent is told IMMEDIATELY instead of chasing a confusing failure — warning
+ *  only, never a block (the approval layer is the real gate, same as destructive-command policy). */
+function posixSyntaxHint(command) {
+  const hits = []
+  if (/\$\([^)]*\)/.test(command)) hits.push("$(...)")
+  if (command.includes("`")) hits.push("backtick")
+  if (/;\s+/.test(command)) hits.push("';' separators (cmd.exe needs && or newline)")
+  if (/2>\s*\/dev\/null|>\s*\/dev\/null|&>\s*\/dev\/null/.test(command)) hits.push("/dev/null (use NUL)")
+  if (/'.*'/.test(command)) hits.push("single quotes (cmd.exe doesn't group)")
+  if (/\$\{[A-Za-z_]/.test(command)) hits.push("${VAR} (use %VAR%)")
+  if (!hits.length) return ""
+  return "[hint: POSIX-only construct(s) detected — " + hits.join(", ") + ". Current shell is cmd.exe; these will NOT work. Use && / NUL / %VAR%, or use the execute tool (node) for complex logic]"
+}
+
+
 // ====================================================================
 // bash — command execution with safety gates
 // ====================================================================
@@ -259,7 +275,9 @@ export const bashTool = {
       shell: ctx.agent?.config?.shell ?? null,
     })
     const filtered = args.filter ? applyLineFilter(result, args.filter) : result
-    return guard ? `${guard.notice}\n\n${filtered}` : filtered
+    const hint = posixSyntaxHint(args.command)
+    const body = guard ? `${guard.notice}\n\n${filtered}` : filtered
+    return hint ? `${hint}\n${body}` : body
   },
 }
 

package/src/tools/web.mjs

@@ -1,6 +1,6 @@
 import { DESC, truncate, stripTags, htmlToText, isPrivateHost } from "./shared.mjs";
 import { URL } from "node:url";
-import { resolveWebProxy, proxyFetch } from "../proxy.mjs";
+import { proxyFetch } from "../proxy.mjs";
 
 export const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
 const FETCH_TIMEOUT = 15_000
@@ -41,8 +41,9 @@ const ENGINES = [{ name: "bing", label: "Bing", url: bingUrl, extract: extractBi
 const ENGINE_NAMES = ENGINES.map(e => e.name)
 
 /** Structured search via Tavily (optional — config.websearch.apiKey). Returns
- *  { engine, results } or null to fall back to Bing HTML scraping. */
-async function fetchTavily(query, limit, ctx) {
+ *  { engine, results } or null to fall back to Bing HTML scraping.
+ *  proxyUri: explicit per-call proxy (args.proxy) — never the config.json one. */
+async function fetchTavily(query, limit, ctx, proxyUri) {
   const apiKey = ctx?.agent?.config?.websearch?.apiKey
   if (!apiKey) return null
   const ctrl = new AbortController()
@@ -53,7 +54,7 @@ async function fetchTavily(query, limit, ctx) {
       headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
       body: JSON.stringify({ query, search_depth: "basic", max_results: limit, include_answer: false, include_raw_content: false }),
       signal: ctrl.signal,
-    }, resolveWebProxy(ctx))
+    }, proxyUri)
     if (!response.ok) return null
     const data = await response.json()
     const results = (Array.isArray(data.results) ? data.results : []).map((r) => ({
@@ -64,14 +65,14 @@ async function fetchTavily(query, limit, ctx) {
   finally { clearTimeout(timer) }
 }
 
-async function fetchEngine(engine, query, page, ctx) {
+async function fetchEngine(engine, query, page, proxyUri) {
   const ctrl = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT)
   try {
     const response = await proxyFetch(engine.url(query, page), {
       headers: { "User-Agent": engine.ua, "Accept-Language": "en-US,en;q=0.9,zh-CN;q=0.8" },
       signal: ctrl.signal,
-    }, resolveWebProxy(ctx))
+    }, proxyUri)
     if (!response.ok) return null
     const html = await response.text()
     const results = engine.extract(html)
@@ -90,6 +91,7 @@ export const websearchTool = {
       limit: { type: "number", description: "Max results (default 8, max 20)" },
       engine: { type: "string", enum: ENGINE_NAMES, description: "Specific engine — \"bing\" (Bing). Omit to search all engines concurrently." },
       page: { type: "number", description: "Page number for pagination (1-based, default 1). Only used when engine is specified." },
+      proxy: { type: "string", description: "http://host:port explicit proxy (optional) — use ONLY when passed; no proxy = direct. config.json proxy is NOT auto-applied (2026-08-31 ruling: fixed config breaks domestic sites)" },
     },
     required: ["query"],
   },
@@ -97,20 +99,23 @@ export const websearchTool = {
   async execute(args, ctx) {
     const limit = Math.min(args.limit ?? 8, 20)
     const page = Math.max(1, args.page ?? 1)
+    // 2026-08-31 ruling: proxy is a PER-CALL decision (args.proxy), never the config.json
+    // fixed configuration. Model picks by target: github/foreign → pass proxy; gitee/domestic → omit.
+    const proxyUri = args.proxy ?? null
     // Structured search first when a Tavily key is configured — stable, dated,
     // no HTML scraping. Falls back to Bing silently.
-    const tavily = await fetchTavily(args.query, limit, ctx)
+    const tavily = await fetchTavily(args.query, limit, ctx, proxyUri)
     if (tavily && tavily.results.length > 0) {
       return truncate(tavily.results.slice(0, limit).map((r, i) => `${i + 1}. [tavily] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
     }
     if (args.engine) {
       const engine = ENGINES.find(e => e.name === args.engine)
       if (!engine) return `Unknown engine '${args.engine}'. Available: ${ENGINE_NAMES.join(", ")}`
-      const fetched = await fetchEngine(engine, args.query, page, ctx)
+      const fetched = await fetchEngine(engine, args.query, page, proxyUri)
       if (!fetched || fetched.results.length === 0) return "(no results)"
       return truncate(fetched.results.slice(0, limit).map((r, i) => `${i + 1}. [${engine.label}] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
     }
-    const promises = ENGINES.map(e => fetchEngine(e, args.query, 1, ctx))
+    const promises = ENGINES.map(e => fetchEngine(e, args.query, 1, proxyUri))
     const fetched = (await Promise.all(promises)).filter(Boolean)
     if (fetched.length === 0) return "(no results)"
     const merged = [], indexes = fetched.map(() => 0)
@@ -156,16 +161,39 @@ export function resolveRedirectTarget(loc, baseUrl) {
   return { target }
 }
 
+/** Heuristic: a fetch result that is a near-empty shell or a region-block page hides
+ *  the real content. Flags the pattern so the model switches strategy instead of
+ *  re-fetching blind (2026-08-31: 21-char MiniMax SPA shell + "App unavailable in
+ *  region" Claude page both wasted an hour of round trips). */
+export function detectSparseHtml(html, text) {
+  if (text.length >= 300) return ""
+  if (/unavailable in (your )?region|not available in (your )?region|app-unavailable|enable.?javascript|just a moment|attention required|cf-browser-verification/i.test(html)) {
+    return "\n\n[fetch hint: page looks region-blocked or JS-gated (body <300 chars). Try a search MCP tool (configured provider) or the site's .md/raw/mirror endpoint]"
+  }
+  if (/<div[^>]+id="(app|root)"[^>]*>\s*<\/div>|id="app"|id="root"/i.test(html)) {
+    return "\n\n[fetch hint: page is a JS-rendered SPA shell (body <300 chars) — content loads client-side. Try a search MCP tool or the site's .md/API endpoint]"
+  }
+  return ""
+}
+
 export const fetchTool = {
   name: "fetch",
   description: DESC("fetch"),
-  parameters: { type: "object", properties: { url: { type: "string", description: "http/https URL" } }, required: ["url"] },
+  parameters: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "http/https URL" },
+      proxy: { type: "string", description: "http://host:port explicit proxy (optional) — use ONLY when passed; no proxy = direct. config.json proxy is NOT auto-applied (2026-08-31 ruling); pick per target (github/foreign sites need a proxy, gitee/domestic don't)" },
+    },
+    required: ["url"],
+  },
   readonly: true,
-  async execute(args, ctx) {
+  async execute(args, _ctx) {
     if (!/^https?:\/\//.test(args.url)) throw new Error("url must start with http:// or https://")
     if (isPrivateUrl(args.url)) throw new Error("fetch blocked: internal/private/metadata addresses are not allowed")
     try {
-      const proxyUri = resolveWebProxy(ctx)
+      // 2026-08-31 ruling: per-call decision — args.proxy when passed, direct otherwise.
+      const proxyUri = args.proxy ?? null
       const response = await proxyFetch(args.url, { headers: { "User-Agent": UA } }, proxyUri)
       if (!response.ok) {
         if ([301, 302, 307, 308].includes(response.status)) {
@@ -179,14 +207,16 @@ export const fetchTool = {
             if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}`)
             const ct2 = headerOf(r2, "content-type") ?? ""
             const b2 = await r2.text()
-            return ct2.includes("text/html") ? truncate(htmlToText(b2)) : truncate(b2)
+            if (ct2.includes("text/html")) { const t = htmlToText(b2); return truncate(t + detectSparseHtml(b2, t)) }
+            return truncate(b2)
           }
         }
         throw new Error(`fetch failed: HTTP ${response.status}`)
       }
       const ct = headerOf(response, "content-type") ?? ""
       const body = await response.text()
-      return ct.includes("text/html") ? truncate(htmlToText(body)) : truncate(body)
+      if (ct.includes("text/html")) { const t = htmlToText(body); return truncate(t + detectSparseHtml(body, t)) }
+      return truncate(body)
     } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`, { cause: e }) }
   },
 }

package/src/tools/websearch.md

@@ -5,9 +5,11 @@ Parameters:
 - limit: Max results (default 8, max 20)
 - engine: Specific engine to use — "bing" (Bing). Omit to search all engines concurrently.
 - page: Page number for pagination (1-based, default 1). Only used when engine is specified.
+- proxy: http://host:port explicit proxy (optional) — use ONLY when passed; no proxy = direct. config.json proxy is NOT auto-applied (2026-08-31 ruling); Bing/foreign sites usually need a proxy, domestic targets don't
 
 Notes:
 - Before searching the web, call `memory_search` first — you may already know the answer from a previous session. Only reach for websearch if memory comes up empty.
 - Use this for information that is NOT in the local codebase — current docs, error messages, API references
 - Follow up with `fetch` to read full pages from the results
-- Proxy support: set `"proxy": {"uri": "http://host:port", "web": true}` in config.json
+- **Weak engine warning**: Bing's index is noisy for technical queries — if a first websearch returns irrelevant/townhall-grade results, DO NOT retry the same query. Configure a search MCP tool (e.g. `glm-websearch` via the MCP config) for technical lookups; websearch is the fallback.
+- Proxy: NOT auto-applied from config.json (2026-08-31 ruling). Pass `proxy: "http://host:port"` explicitly when the target needs one; omit for domestic targets.

package/src/tui/ansi.mjs

@@ -25,6 +25,8 @@ export const ansi = {
   restoreCursor: `${ESC}8`,   // DECRC — restore cursor position
   syncUpdateStart: `${ESC}[?2026h`, // DECSET 2026 — buffer output until syncUpdateEnd
   syncUpdateEnd: `${ESC}[?2026l`,   // DECRST 2026 — flush buffered output atomically
+  wrapOff: `${ESC}[?7l`, // DECRST 7 — disable auto-wrap: over-wide rows hard-truncate at the margin instead of wrapping to the next physical line (2026-08-31 会诊：Ambiguous 宽度字符如 │/—/●/▸ 在中文 locale 终端渲染 2 格而 stringWidth 按 1 格算 → 行实际超宽 → wrap 污染下一物理行 + \x1b[K 清错行 → picker 残影)
+  wrapOn: `${ESC}[?7h`,  // DECSET 7 — restore auto-wrap (TUI exit; also re-enable per-frame after write)
   reset: `${ESC}[0m`,
   dim: `${ESC}[2m`,
   bold: `${ESC}[1m`,

package/src/tui/cmd-new.mjs

@@ -1,4 +1,4 @@
-import { newSession } from "../session.mjs"
+import { newSession, resetSessionState } from "../session.mjs"
 import { C } from "./ansi.mjs"
 
 /** /new command: start a new session in a fresh slot.
@@ -8,11 +8,11 @@ export async function handleNewCommand(ctx) {
 
   const doNewSession = () => {
     const slot = newSession(agent.cwd)
-    agent.history = []
-    agent.tasks = []
-    agent.planMode = false
-    agent.goal = null
-    agent._pendingReminders = []
+    // 2026-08-31 会诊 F3：resetSessionState 清全量会话态（_fullHistory/title/_sessionStart/
+    // _engDesignToken/压缩与验证计数等）——原实现只清 agent.history，新会话首次落盘把旧
+    // 会话完整人类线 + 旧标题写进新 slot（实锤 .19/.3 双副本）。_slot 更新为粘性新槽位。
+    resetSessionState(agent)
+    agent._slot = slot
     state.tasks = []
     state.lines = []
     state.streaming = ""

package/src/tui/cmd-restore.mjs

@@ -1,7 +1,8 @@
 import { ansi, C } from "./ansi.mjs"
 
-/** /restore command: list git checkpoints and roll back to selected snapshot.
- *  ctx: { agent, showPicker, pushLine, pushLabel } */
+/** /restore command: pick a snapshot, then pick ONE file from it to restore.
+ *  Full restore is disabled (v2) — this is the user-side per-file recovery entry
+ *  (CHECKPOINT.md D8). ctx: { agent, showPicker, pushLine, pushLabel } */
 export async function handleRestoreCommand(ctx) {
   const { agent, showPicker, pushLine, pushLabel } = ctx
   const { listCheckpoints, rewind, isGitRepo } = await import("../git/checkpoint.mjs")
@@ -9,25 +10,45 @@ export async function handleRestoreCommand(ctx) {
     pushLine("[rewind] not a git repository, checkpoints unavailable", C.error)
     return
   }
+  // F6 lazy fallback——与 git 工具 checkpoint list/create 入口一致（git-checkpoint.mjs）：外部
+  // git commit 后（HEAD 时间 > 最新快照）先清空过期快照，/restore 不列出 commit 前状态。
+  const { lazyClearIfCommitted } = await import("../tools/git-checkpoint.mjs")
+  await lazyClearIfCommitted(agent.cwd)
   const cps = await listCheckpoints(agent.cwd)
   if (cps.length === 0) {
     pushLine("(no checkpoints — created automatically before each task)", C.dim)
     return
   }
+  // Level 1: pick a snapshot (untracked shown as array length — CHECKPOINT.md D8).
   const entries = [
-    { type: "header", text: "Checkpoints (↑↓ select, Enter restore, Esc cancel)" },
+    { type: "header", text: "Checkpoints — 全量恢复已禁用，逐文件恢复 (↑↓ select, Enter next, Esc cancel)" },
     ...cps.slice(0, 12).map((cp) => ({
       type: "item",
-      text: `${cp.id}  ${new Date(cp.time).toLocaleString()}  (+${cp.untracked} untracked files)`,
+      text: `${cp.id}  ${new Date(cp.time).toLocaleString()}  (+${(cp.untracked ?? []).length} untracked files)`,
       id: cp.id,
     })),
   ]
   const e = await showPicker("Restore Checkpoint", entries)
   if (!e) return
+  const cp = cps.find((c) => c.id === e.id)
+  if (!cp) return
+  // Level 2: pick a file from the snapshot's tracked/untracked merged list.
+  const files = [...(cp.tracked ?? []), ...(cp.untracked ?? [])]
+  if (files.length === 0) {
+    pushLine("该快照无文件，无法逐文件恢复", C.dim)
+    return
+  }
+  const fileEntries = [
+    { type: "header", text: `Files in ${cp.id} (↑↓ select, Enter restore, Esc cancel)` },
+    ...files.map((f) => ({ type: "item", text: f, id: f })),
+  ]
+  const fe = await showPicker("Restore File", fileEntries)
+  if (!fe) return
   try {
-    const summary = await rewind(agent.cwd, e.id)
+    // v2 return: { path, type, restored } — rewind snapshots current state first (reversible).
+    const summary = await rewind(agent.cwd, cp.id, { path: fe.id })
     pushLabel(`❯ Rewind`, ansi.bold + C.warn)
-    pushLine(`Restored to ${e.id}: patch ${summary.patchApplied ? "applied" : "none"}, deleted ${summary.deleted} new files, restored ${summary.restored} file(s)`, C.tool)
+    pushLine(`Restored ${summary.type}: ${summary.path}${summary.restored ? "" : " — nothing restored (snapshot copy missing)"}`, C.tool)
     pushLine("(current state saved as new checkpoint; /restore again to go back)", C.dim)
   } catch (error) {
     pushLine(`[rewind] ${error.message}`, C.error)