thincoder 0.12.53 → 0.12.58

package/src/tools/git-ext.mjs

@@ -0,0 +1,173 @@
+/**
+ * git-ext.mjs — git 工具 F7 扩展 action（clone/init/rebase/remote/clean/switch/apply/worktree/
+ * archive/blame/mv）+ 共享 git 辅助函数（validateRef/runGitStrict/filterLines/snapshotBefore，
+ * 供 git.mjs 核心 action 复用——500 行硬限拆分）。CLI 与 VS Code 两端同构（镜像，修改须两端同批）。
+ */
+import { runGit, truncate } from "./shared.mjs"
+import { execFileSync } from "node:child_process"
+
+/** Keep only output lines matching a regex (git filter, case-insensitive). */
+export 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. */
+export function runGitStrict(cwd, cmdArgs, config = []) {
+  try {
+    const out = execFileSync("git", [...config, ...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). */
+export 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
+}
+
+/** Normalize args.config into `-c key=value` pairs (git -c overrides, e.g. a proxy).
+ *  Values are execFileSync array args (no shell injection) — still reject newlines/empty. */
+export function gitConfigArgs(config) {
+  if (config == null) return []
+  if (!Array.isArray(config)) throw new Error("config must be an array of \"key=value\" strings")
+  const out = []
+  for (const c of config) {
+    if (typeof c !== "string" || !c.trim() || c.includes("\n")) throw new Error(`invalid git -c config entry: ${String(c).slice(0, 60)}`)
+    out.push("-c", c)
+  }
+  return out
+}
+
+/** Snapshot the working tree before a destructive op (reset --hard / checkout file / restore /
+ *  stash pop / branch|tag delete / clean / rebase). Best-effort — a snapshot failure must not
+ *  block the op (the approval/permission layer is the real gate). Returns a note line or "". */
+export 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 ""
+  }
+}
+
+/** F7 扩展 action 主入口（git 工具 switch 的 fall-through 组委托到这里）。 */
+export async function executeExtAction(args, ctx) {
+  switch (args.action) {
+    case "clone": {
+      // Clone a repo into a NEW directory — non-destructive (never touches existing work).
+      if (!args.remote) return "Error: clone requires remote (URL or local path)"
+      const cmdArgs = ["clone", args.remote]
+      if (args.path) cmdArgs.push(args.path)
+      const r = runGitStrict(ctx.cwd, cmdArgs, gitConfigArgs(args.config))
+      return r.ok ? truncate(r.out || `Cloned ${args.remote}`) : truncate(`git clone failed: ${r.err || r.out}`)
+    }
+    case "init": {
+      const r = runGitStrict(ctx.cwd, ["init"])
+      return r.ok ? truncate(r.out || "Initialized empty git repository") : truncate(`git init failed: ${r.err || r.out}`)
+    }
+    case "rebase": {
+      // Belt-and-braces snapshot: bare rebase refuses uncommitted changes (unless
+      // --autostash), but --autostash restore-failure / interrupted-rebase scenarios
+      // can leave the working tree damaged — the snapshot makes that recoverable.
+      // The snapshot line is included on FAILURE too: a rejected rebase (unstaged
+      // changes) is exactly when the model must know its work is protected (F1 loop).
+      const snap = await snapshotBefore(ctx, "rebase")
+      const sub = args.rebaseAction ?? "start"
+      const cmdArgs = ["rebase"]
+      if (sub === "abort") cmdArgs.push("--abort")
+      else if (sub === "continue") cmdArgs.push("--continue")
+      else { if (!args.ref) return "Error: rebase requires ref (branch/commit to rebase onto)"; cmdArgs.push(validateRef(args.ref)) }
+      const r = runGitStrict(ctx.cwd, cmdArgs)
+      return r.ok ? truncate(snap + (r.out || `Rebase ${sub} complete`)) : truncate(snap + `git rebase failed: ${r.err || r.out} — use rebaseAction=abort to abort`)
+    }
+    case "remote": {
+      const sub = args.remoteAction ?? "list"
+      if (sub === "list") return truncate(filterLines(runGit(ctx.cwd, ["remote", "-v"]) || "(no remotes)", args.filter))
+      if (!args.remote) return `Error: remote ${sub} requires remote (name)`
+      validateRef(args.remote, "remote name")
+      if (sub === "add" || sub === "set-url") {
+        if (!args.remoteUrl) return `Error: remote ${sub} requires remoteUrl`
+        const r = runGitStrict(ctx.cwd, ["remote", sub === "add" ? "add" : "set-url", args.remote, args.remoteUrl])
+        return r.ok ? `Remote ${args.remote} ${sub === "add" ? "added" : "URL set"}` : truncate(`git remote ${sub} failed: ${r.err || r.out}`)
+      }
+      if (sub === "remove") {
+        const r = runGitStrict(ctx.cwd, ["remote", "remove", args.remote])
+        return r.ok ? `Remote ${args.remote} removed` : truncate(`git remote remove failed: ${r.err || r.out}`)
+      }
+      return "Error: remote requires remoteAction — use: list | add | remove | set-url"
+    }
+    case "clean": {
+      // Destructive: removes untracked files/dirs — snapshot first (guard parity).
+      // dryRun (-n) is a preview: no deletion, no snapshot.
+      const snap = args.dryRun ? "" : await snapshotBefore(ctx, "clean")
+      const cmdArgs = ["clean", args.dryRun ? "-n" : "-f", "-d"]
+      const r = runGitStrict(ctx.cwd, cmdArgs)
+      return r.ok ? truncate(snap + (r.out || (args.dryRun ? "Nothing to clean (dry run)" : "Clean complete"))) : truncate(snap + `git clean failed: ${r.err || r.out}`)
+    }
+    case "switch": {
+      if (!args.name) return "Error: switch requires name (branch)"
+      validateRef(args.name, "branch")
+      const cmdArgs = ["switch"]
+      if (args.create) cmdArgs.push("-c")
+      cmdArgs.push(args.name)
+      const r = runGitStrict(ctx.cwd, cmdArgs)
+      return r.ok ? truncate(r.out || `Switched to branch ${args.name}`) : truncate(`git switch failed: ${r.err || r.out}`)
+    }
+    case "apply": {
+      // Apply a patch — non-destructive (fails cleanly on conflict, applies nothing).
+      if (!args.path) return "Error: apply requires path (patch file)"
+      const r = runGitStrict(ctx.cwd, ["apply", "--", args.path])
+      return r.ok ? truncate(r.out || `Applied ${args.path}`) : truncate(`git apply failed: ${r.err || r.out}`)
+    }
+    case "worktree": {
+      const sub = args.worktreeAction ?? "list"
+      if (sub === "list") return truncate(filterLines(runGit(ctx.cwd, ["worktree", "list"]) || "(no worktrees)", args.filter))
+      if (sub === "add") {
+        if (!args.path) return "Error: worktree add requires path (new worktree directory)"
+        const cmdArgs = ["worktree", "add", args.path]
+        if (args.ref) cmdArgs.push(validateRef(args.ref))
+        const r = runGitStrict(ctx.cwd, cmdArgs)
+        return r.ok ? truncate(r.out || `Worktree added at ${args.path}`) : truncate(`git worktree add failed: ${r.err || r.out}`)
+      }
+      if (sub === "remove") {
+        if (!args.path) return "Error: worktree remove requires path"
+        const r = runGitStrict(ctx.cwd, ["worktree", "remove", args.path])
+        return r.ok ? truncate(r.out || `Worktree removed: ${args.path}`) : truncate(`git worktree remove failed: ${r.err || r.out}`)
+      }
+      return "Error: worktree requires worktreeAction — use: list | add | remove"
+    }
+    case "archive": {
+      // Write a tar of a commit/branch — non-destructive (output file only).
+      if (!args.path) return "Error: archive requires path (output file)"
+      const cmdArgs = ["archive", "--format=tar", "-o", args.path]
+      if (args.ref) cmdArgs.push(validateRef(args.ref))
+      else cmdArgs.push("HEAD")
+      const r = runGitStrict(ctx.cwd, cmdArgs)
+      return r.ok ? truncate(r.out || `Archived ${args.ref ?? "HEAD"} to ${args.path}`) : truncate(`git archive failed: ${r.err || r.out}`)
+    }
+    case "blame": {
+      if (!args.path) return "Error: blame requires path (file)"
+      const out = runGit(ctx.cwd, ["blame", "--", args.path])
+      return truncate(out || `(no blame output for ${args.path})`)
+    }
+    case "mv": {
+      if (!args.path || !args.dest) return "Error: mv requires path (source) and dest (destination)"
+      const r = runGitStrict(ctx.cwd, ["mv", "--", args.path, args.dest])
+      return r.ok ? truncate(r.out || `Moved ${args.path} → ${args.dest}`) : truncate(`git mv failed: ${r.err || r.out}`)
+    }
+    default:
+      throw new Error(`Unknown ext action: ${args.action}`)
+  }
+}

package/src/tools/git.md

@@ -1,6 +1,6 @@
 Run a git command. Only works inside a git repository.
 
-**Route to git instead of bash:** `git status`→status, `git log`→log, `git diff`→diff, `git show`→show, `git add`→add, `git rm`→rm, `git commit -m`→commit, `git push <remote> <branch> <tag>`→push, `git tag`→tag, `git branch`→branch, `git checkout`→checkout, `git restore`→restore, `git stash`→stash, `git fetch/pull`→fetch/pull, `git reset`→reset, `git revert`→revert, `git merge`→merge, `git cherry-pick`→cherry-pick, `git ls-remote`→ls-remote.
+**Route to git instead of bash:** `git status`→status, `git log`→log, `git diff`→diff, `git show`→show, `git add`→add, `git rm`→rm, `git commit -m`→commit, `git push <remote> <branch> <tag>`→push, `git tag`→tag, `git branch`→branch, `git checkout`→checkout, `git restore`→restore, `git stash`→stash, `git fetch/pull`→fetch/pull, `git reset`→reset, `git revert`→revert, `git merge`→merge, `git cherry-pick`→cherry-pick, `git ls-remote`→ls-remote, `git clone`→clone, `git init`→init, `git rebase`→rebase, `git remote`→remote, `git clean`→clean, `git switch`→switch, `git apply`→apply, `git worktree`→worktree, `git archive`→archive, `git blame`→blame, `git mv`→mv.
 
 - action='diff': unified diff — what changed since last commit. staged=true for staged-only; ref=<ref> to compare a commit/branch; path=<dir> to scope.
 - action='status': working tree state — staged / unstaged / untracked / conflicts, categorized.
@@ -20,16 +20,28 @@ Run a git command. Only works inside a git repository.
 - action='merge': merge ref=<branch/commit>; conflicts reported for you to resolve.
 - action='cherry-pick': cherry-pick ref=<commit>.
 - action='ls-remote': light remote-ref check — which refs a remote has (read-only, network). remote=<origin>, ref=<branch/tag> optional, config for proxy.
+- action='clone': clone a repo. remote required (URL or local path); path optional (target dir).
+- action='init': init a repo in the current (work)dir.
+- action='rebase': rebase onto ref. rebaseAction=start (ref required) / abort / continue（操作前自动快照，checkpointAction=rewind 恢复）.
+- action='remote': manage remotes. remoteAction=list / add / remove / set-url; remoteUrl for add/set-url.
+- action='clean': remove untracked files/dirs. dryRun for -n preview（真删除操作前自动快照，checkpointAction=rewind 恢复）.
+- action='switch': switch branch. name required; create for -c (new branch).
+- action='apply': apply a patch. path required (patch file).
+- action='worktree': manage worktrees. worktreeAction=list / add (path, ref) / remove (path).
+- action='archive': write a tar of ref (default HEAD). path required (output file).
+- action='blame': file blame. path required.
+- action='mv': rename/move. path (source) + dest required.
 - action='checkpoint': git snapshots. checkpointAction=list/create/rewind/cat/versions; checkpointId required for rewind/cat.
+- Destructive ops (checkout -- path / restore / reset --hard / stash pop / branch|tag delete / clean / rebase) auto-snapshot first — restore via checkpointAction=rewind.
 
 Parameters:
-- action (required): diff / status / log / show / checkpoint / add / rm / commit / push / tag / branch / checkout / restore / stash / fetch / pull / reset / revert / merge / cherry-pick / ls-remote
-- workdir: run git in this workspace subdirectory (monorepo / multi-repo). Confined to the workspace. Default: cwd
-- config: (network actions push/fetch/pull/ls-remote) git -c overrides, e.g. ["http.proxy=http://10.2.2.112:3128"] for blocked remotes
-- path: (diff/log/add/commit/checkout/restore/rm) file or directory to scope / stage / restore
-- ref: (show/diff/checkout/reset/revert/merge/cherry-pick/tag:create/branch:create) commit/branch/ref; (push/pull/fetch) the branch or tag (space-separated for multiple)
-- name: (branch/tag) the branch or tag name
-- remote: (push/fetch/pull) remote name (e.g. origin); default: current upstream
+- action (required): 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
+- workdir: run git in this subdirectory (monorepo / multi-repo). Path relative to cwd — no directory restriction. Default: cwd
+- config: (network actions push/fetch/pull/ls-remote/clone) git -c overrides, e.g. ["http.proxy=http://10.2.2.112:3128"] for blocked remotes
+- path: (diff/log/add/commit/checkout/restore/rm/apply/archive/blame/mv/worktree) file or directory to scope / stage / restore
+- ref: (show/diff/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)
+- name: (branch/tag/switch) the branch or tag name
+- remote: (push/fetch/pull/remote/clone) remote name (e.g. origin) or URL; default: current upstream
 - tags: (push) also push all tags (--tags)
 - staged: (diff) staged changes; (restore) the staged copy
 - count: (log) number of commits (default 10)
@@ -39,3 +51,4 @@ Parameters:
 - tagAction: (tag) list / create / delete — branchAction: (branch) list / create / delete / switch — stashAction: (stash) push / pop / list
 - filter: (read-only actions) keep only output lines matching this regex (case-insensitive)
 - checkpointAction: (checkpoint) list / create / rewind / cat / versions — checkpointId: snapshot id (rewind/cat)
+- remoteAction: (remote) list / add / remove / set-url — remoteUrl: (remote add/set-url) URL — rebaseAction: (rebase) start / abort / continue — dryRun: (clean) -n preview — create: (switch) -c — dest: (mv) destination — worktreeAction: (worktree) list / add / remove

package/src/tools/git.mjs

@@ -3,21 +3,11 @@ 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 } 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
@@ -30,65 +20,18 @@ function runGitRaw(cwd, cmdArgs, config = []) {
   }
 }
 
-/** 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, config = []) {
-  try {
-    const out = execFileSync("git", [...config, ...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
-}
-
-/** Normalize args.config into `-c key=value` pairs (git -c overrides, e.g. a proxy).
- *  Values are execFileSync array args (no shell injection) — still reject newlines/empty. */
-function gitConfigArgs(config) {
-  if (config == null) return []
-  if (!Array.isArray(config)) throw new Error("config must be an array of \"key=value\" strings")
-  const out = []
-  for (const c of config) {
-    if (typeof c !== "string" || !c.trim() || c.includes("\n")) throw new Error(`invalid git -c config entry: ${String(c).slice(0, 60)}`)
-    out.push("-c", c)
-  }
-  return out
-}
 
-/** 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. */
+/** Resolve workdir relative to cwd — no boundary assertion
+ *  (§10.1 2026-09-02: workspace confinement removed; git itself is not
+ *  directory-limited — same boundary as bash). */
 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
+  return resolve(cwd, workdir)
 }
 
-/** 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",
@@ -96,11 +39,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", "ls-remote"], description: "diff / status / log / show / checkpoint / add / rm / commit / push / tag / branch / checkout / restore / stash / fetch / pull / reset / revert / merge / cherry-pick / ls-remote" },
+      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" },
@@ -108,23 +51,31 @@ export const gitTool = {
       // write-op params
       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" },
+      workdir: { type: "string", description: "Run git in this subdirectory (monorepo / multi-repo). Path relative to cwd — no directory restriction. 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"],
   },
   readonly: false,
   async execute(args, ctx) {
-    // 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.
+    // workdir: run git in a subdirectory (monorepo / multi-repo). Shadow ctx.cwd so
+    // every action + snapshotBefore + checkpoint resolves against the workdir.
     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.
@@ -203,7 +154,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)")
       }
@@ -357,66 +319,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`
     }
   },
 }
@@ -445,45 +365,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/lint.md

@@ -1,6 +1,6 @@
 Run the appropriate linter/checker for a file. Auto-detects based on file extension and project config.
 Without 'full', runs a fast node --check (JS/TS syntax only, catches parse errors in milliseconds).
-With 'full', runs the language-aware cascade: eslint → tsc –noEmit → node --check (JS/TS/TSX); ruff (Python); cargo check (Rust); go vet (Go).
+With 'full', runs the language-aware cascade: tsc –noEmit (TS); ruff (Python); cargo check (Rust); go vet (Go). JS/JSX files fall back to node --check; TS uses tsc --noEmit (requires tsconfig.json).
 Use the fast default after every write/edit; use 'full' before declaring a task complete.
 
 Parameters:

package/src/tools/linter.mjs

@@ -1,7 +1,7 @@
 import { DESC, resolveInCwd } from "./shared.mjs"
 import { execFileSync } from "node:child_process"
 import { existsSync } from "node:fs"
-import { join, relative } from "node:path"
+import { join } from "node:path"
 
 export const lintTool = {
   name: "lint",
@@ -26,7 +26,8 @@ export const lintTool = {
       return nodeCheckResult(abs)
     }
 
-    // Full cascade: language-aware (eslint → tsc → node --check, etc.)
+    // Full cascade: language-aware (tsc → node --check, ruff, cargo, go vet —
+    // third-party linter cascade removed 2026-09-02, TOOLS.md §10.2: zero-dependency lint)
     const ext = abs.split(".").pop()?.toLowerCase()
     const checkers = LANG_CHECKERS[ext]
     if (!checkers) return nodeCheckResult(abs) // fall back to node --check
@@ -54,33 +55,7 @@ function nodeCheckResult(abs) {
   }
 }
 
-// ─── Full-check cascade checkers ──────────────────────
-
-async function eslintCheck(file, { cwd, existsSync, execFileSync, join, relative }) {
-  let dir = file.split(/[\\/]/).slice(0, -1).join("/") || "."
-  while (true) {
-    for (const cfg of [".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json", ".eslintrc.yaml", ".eslintrc.yml", "eslint.config.js", "eslint.config.mjs"]) {
-      if (existsSync(join(cwd, dir, cfg))) {
-        try {
-          const cfgDir = join(cwd, dir)
-          const relPath = relative(cfgDir, file)
-          execFileSync("npx", ["eslint", "--no-color", "--format", "compact", relPath], {
-            cwd: cfgDir, encoding: "utf8", timeout: 30000, stdio: ["ignore", "pipe", "pipe"],
-          })
-          return "✓ eslint: no issues"
-        } catch (e) {
-          const stdout = (e.stdout || "").trim()
-          if (stdout) return stdout
-          return `✗ eslint: ${(e.stderr || e.message).slice(0, 500)}`
-        }
-      }
-    }
-    const parent = dir.split("/").slice(0, -1).join("/")
-    if (!parent || parent === dir) break
-    dir = parent
-  }
-  return null
-}
+// ─── Full-check cascade checkers (third-party linter branch removed 2026-09-02, TOOLS.md §10.2) ──────
 
 async function tscCheck(file, { cwd, existsSync, execFileSync, join }) {
   if (!existsSync(join(cwd, "tsconfig.json"))) return null
@@ -142,14 +117,11 @@ async function goVet(file, { cwd, execFileSync }) {
 }
 
 const LANG_CHECKERS = {
-  js:  [eslintCheck],
-  mjs: [eslintCheck],
-  cjs: [eslintCheck],
-  jsx: [eslintCheck],
-  ts:  [eslintCheck, tscCheck],
-  tsx: [eslintCheck, tscCheck],
-  mts: [eslintCheck, tscCheck],
-  cts: [eslintCheck, tscCheck],
+  // js/mjs/cjs/jsx fall back to node --check (no entry — third-party linter cascade removed 2026-09-02, TOOLS.md §10.2)
+  ts:  [tscCheck],
+  tsx: [tscCheck],
+  mts: [tscCheck],
+  cts: [tscCheck],
   py:  [ruffCheck],
   rs:  [cargoCheck],
   go:  [goVet],

package/src/tools/patch.mjs

@@ -103,7 +103,7 @@ export const applyPatchTool = {
   parameters: {
     type: "object",
     properties: {
-      patch: { type: "string", description: "Unified diff. May span multiple files; --- / +++ headers per file, @@ -old,count +new,count @@ hunks. Use --- /dev/null to create a file." },
+      patch: { type: "string", description: "Unified diff. May span multiple files (multiple --- / +++ header pairs — including creating MULTIPLE new files via --- /dev/null); --- / +++ headers per file, @@ -old,count +new,count @@ hunks." },
     },
     required: ["patch"],
   },