@rethunk/mcp-multi-root-git 1.0.0 → 2.1.0

package/dist/server/git-inventory-tool.js

@@ -8,66 +8,39 @@ import { MAX_INVENTORY_ROOTS_DEFAULT, WorkspacePickSchema } from "./schemas.js";
 export function registerGitInventoryTool(server) {
     server.addTool({
         name: "git_inventory",
-        description: "Read-only push-prep inventory: status + ahead/behind per root. " +
-            "Uses each repo's configured upstream (`@{u}`) unless both `remote` and `branch` are set. " +
-            "Presets from `.rethunk/git-mcp-presets.json`; use `presetMerge` to combine with inline paths.",
+        description: "Read-only status + ahead/behind per root. See docs/mcp-tools.md.",
         parameters: WorkspacePickSchema.extend({
-            nestedRoots: z
-                .array(z.string())
-                .optional()
-                .describe("Paths relative to git toplevel. If empty/omitted, only the repo root is listed. With `presetMerge`, merged with preset paths."),
-            preset: z
-                .string()
-                .optional()
-                .describe("Named preset from .rethunk/git-mcp-presets.json (at git toplevel)."),
+            nestedRoots: z.array(z.string()).optional(),
+            preset: z.string().optional(),
             presetMerge: z
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("When true, merge `nestedRoots` with preset nestedRoots instead of replacing."),
-            remote: z
-                .string()
-                .optional()
-                .describe("Fixed upstream remote; must be set together with `branch` to override auto upstream."),
-            branch: z
-                .string()
-                .optional()
-                .describe("Fixed upstream branch name; must be set together with `remote`."),
-            maxRoots: z
-                .number()
-                .int()
-                .min(1)
-                .max(256)
-                .optional()
-                .default(MAX_INVENTORY_ROOTS_DEFAULT)
-                .describe("Max nested roots to process (cap)."),
+                .describe("Merge with preset instead of replacing."),
+            remote: z.string().optional().describe("Pair with `branch`."),
+            branch: z.string().optional().describe("Pair with `remote`."),
+            maxRoots: z.number().int().min(1).max(256).optional().default(MAX_INVENTORY_ROOTS_DEFAULT),
         }),
         execute: async (args) => {
             const pre = requireGitAndRoots(server, args, args.preset);
             if (!pre.ok) {
                 return jsonRespond(pre.error);
             }
-            const fixedRemote = args.remote;
-            const fixedBranch = args.branch;
-            const hasRemote = fixedRemote !== undefined && fixedRemote.trim() !== "";
-            const hasBranch = fixedBranch !== undefined && fixedBranch.trim() !== "";
+            const rawRemote = args.remote?.trim();
+            const rawBranch = args.branch?.trim();
+            const hasRemote = rawRemote !== undefined && rawRemote !== "";
+            const hasBranch = rawBranch !== undefined && rawBranch !== "";
             if (hasRemote !== hasBranch) {
-                return jsonRespond({
-                    error: "remote_branch_mismatch",
-                    message: "Set both `remote` and `branch` for fixed upstream, or omit both for auto `@{u}`.",
-                });
+                return jsonRespond({ error: "remote_branch_mismatch" });
             }
-            const useFixed = hasRemote && hasBranch;
-            if (useFixed) {
-                const r = String(fixedRemote).trim();
-                const b = String(fixedBranch).trim();
-                if (!isSafeGitUpstreamToken(r) || !isSafeGitUpstreamToken(b)) {
-                    return jsonRespond({
-                        error: "invalid_remote_or_branch",
-                        message: "remote and branch must be plain tokens: no whitespace, control characters, `@`, `..`, leading `-`, or git rev metacharacters like `^ : ? * [ ] { } ~ \\`.",
-                    });
+            let upstream = { mode: "auto" };
+            if (hasRemote && hasBranch && rawRemote && rawBranch) {
+                if (!isSafeGitUpstreamToken(rawRemote) || !isSafeGitUpstreamToken(rawBranch)) {
+                    return jsonRespond({ error: "invalid_remote_or_branch" });
                 }
+                upstream = { mode: "fixed", remote: rawRemote, branch: rawBranch };
             }
+            const useFixed = upstream.mode === "fixed";
             const allJson = [];
             const mdChunks = [];
             for (const workspaceRoot of pre.roots) {
@@ -77,31 +50,14 @@ export function registerGitInventoryTool(server) {
                     if (args.format === "json") {
                         allJson.push({
                             workspace_root: workspaceRoot,
-                            upstream: {
-                                mode: useFixed ? "fixed" : "auto",
-                                remote: fixedRemote,
-                                branch: fixedBranch,
-                            },
+                            ...(upstream.mode === "fixed" ? { upstream } : {}),
                             entries: [
-                                {
-                                    label: workspaceRoot,
-                                    path: workspaceRoot,
-                                    branchStatus: "",
-                                    shortStatus: "",
-                                    detached: false,
-                                    headAbbrev: "",
-                                    upstreamMode: useFixed ? "fixed" : "auto",
-                                    upstreamRef: null,
-                                    ahead: null,
-                                    behind: null,
-                                    upstreamNote: "",
-                                    skipReason: JSON.stringify(err),
-                                },
+                                makeSkipEntry(workspaceRoot, workspaceRoot, upstream.mode, JSON.stringify(err)),
                             ],
                         });
                     }
                     else {
-                        mdChunks.push(`# Git inventory`, "", jsonRespond(err), "");
+                        mdChunks.push(`### ${workspaceRoot}\n${jsonRespond(err)}`);
                     }
                     continue;
                 }
@@ -124,31 +80,31 @@ export function registerGitInventoryTool(server) {
                     nestedRootsTruncated = true;
                 }
                 const headerNote = useFixed
-                    ? `remote/branch (fixed): ${fixedRemote}/${fixedBranch}`
-                    : "upstream: per-repo @{u} (configured upstream)";
+                    ? `upstream (fixed): ${upstream.remote}/${upstream.branch}`
+                    : "upstream: @{u}";
                 const entries = [];
                 if (nestedRoots?.length) {
                     const jobs = [];
                     for (const rel of nestedRoots) {
                         const { abs, underTop } = validateRepoPath(rel, top);
                         if (!underTop) {
-                            entries.push(makeSkipEntry(rel, abs, useFixed ? "fixed" : "auto", "(path escapes git toplevel — rejected)"));
+                            entries.push(makeSkipEntry(rel, abs, upstream.mode, "(path escapes git toplevel — rejected)"));
                             continue;
                         }
                         if (!gitRevParseGitDir(abs)) {
-                            entries.push(makeSkipEntry(rel, abs, useFixed ? "fixed" : "auto", "(not a git work tree — skip)"));
+                            entries.push(makeSkipEntry(rel, abs, upstream.mode, "(not a git work tree — skip)"));
                             continue;
                         }
                         jobs.push({ label: rel, abs });
                     }
-                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, useFixed ? fixedRemote : undefined, useFixed ? fixedBranch : undefined));
+                    const computed = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, (j) => collectInventoryEntry(j.label, j.abs, upstream.remote, upstream.branch));
                     entries.push(...computed);
                 }
                 else if (!gitRevParseGitDir(top)) {
-                    entries.push(makeSkipEntry(".", top, useFixed ? "fixed" : "auto", "(not a git work tree — unexpected)"));
+                    entries.push(makeSkipEntry(".", top, upstream.mode, "(not a git work tree — unexpected)"));
                 }
                 else {
-                    const one = await collectInventoryEntry(".", top, useFixed ? fixedRemote : undefined, useFixed ? fixedBranch : undefined);
+                    const one = await collectInventoryEntry(".", top, upstream.remote, upstream.branch);
                     entries.push(one);
                 }
                 if (args.format === "json") {
@@ -159,22 +115,14 @@ export function registerGitInventoryTool(server) {
                             nestedRootsTruncated: true,
                             nestedRootsOmittedCount,
                         }),
-                        upstream: useFixed
-                            ? { mode: "fixed", remote: fixedRemote, branch: fixedBranch }
-                            : { mode: "auto" },
+                        ...(upstream.mode === "fixed" ? { upstream } : {}),
                         entries,
                     });
                 }
                 else {
-                    const sections = [
-                        "# Git inventory",
-                        "",
-                        `workspace_root: ${top}`,
-                        headerNote,
-                        "",
-                    ];
+                    const sections = [`### ${top}`, headerNote];
                     if (nestedRootsTruncated) {
-                        sections.push(`nested_roots_truncated: ${nestedRootsOmittedCount} path(s) not listed (maxRoots=${maxRoots})`, "");
+                        sections.push(`nested_roots_truncated: ${nestedRootsOmittedCount} path(s) not listed (maxRoots=${maxRoots})`);
                     }
                     for (const e of entries) {
                         sections.push(...buildInventorySectionMarkdown(e));
@@ -185,7 +133,7 @@ export function registerGitInventoryTool(server) {
             if (args.format === "json") {
                 return jsonRespond({ inventories: allJson });
             }
-            return mdChunks.join("\n\n---\n\n");
+            return ["# Git inventory", ...mdChunks].join("\n\n");
         },
     });
 }

package/dist/server/git-log-tool.js

@@ -0,0 +1,276 @@
+import { basename } from "node:path";
+import { z } from "zod";
+import { asyncPool, GIT_SUBPROCESS_PARALLELISM, gitTopLevel, spawnGitAsync } from "./git.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireGitAndRoots } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_COMMITS_HARD_CAP = 500;
+const DEFAULT_MAX_COMMITS = 50;
+const DEFAULT_SINCE = "7.days";
+// Field separator written by git into stdout — we use git's %x01 (SOH) escape.
+// The format string itself is safe ASCII; git emits the byte.
+const FIELD_SEP_OUT = "\x01"; // what git outputs (SOH)
+const RECORD_SEP_OUT = "\x02"; // what git outputs (STX) — used as record-START marker
+// git log --pretty tformat: sha7, shaFull, subject, author, email, ISO date, relative date.
+// %x02 is placed at the START of each record (tformat adds \n as terminator after each).
+// Splitting stdout on \x02 then gives empty-first-chunk + one chunk per commit,
+// each structured as:  <fields>\x01\n\n <shortstat text>\n
+// Fields are separated by %x01; the trailing \x01 before \n leaves one empty last field (ignored).
+const PRETTY_FORMAT = "%x02%h%x01%H%x01%s%x01%aN%x01%aE%x01%aI%x01%ar%x01";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a shortstat line like "3 files changed, 12 insertions(+), 5 deletions(-)"
+ * Returns undefined when the line doesn't match (e.g. empty diff).
+ */
+function parseShortstat(line) {
+    const m = /(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/.exec(line);
+    if (!m)
+        return undefined;
+    return {
+        filesChanged: parseInt(m[1] ?? "0", 10),
+        insertions: parseInt(m[2] ?? "0", 10),
+        deletions: parseInt(m[3] ?? "0", 10),
+    };
+}
+/**
+ * Fetch the current branch name (or detached HEAD fallback).
+ */
+async function gitCurrentBranch(cwd, branchArg) {
+    if (branchArg?.trim())
+        return branchArg.trim();
+    const r = await spawnGitAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (r.ok)
+        return r.stdout.trim();
+    return "HEAD";
+}
+/**
+ * Run git log for a single repo root and return structured data.
+ */
+async function runGitLog(opts) {
+    const { top, since, paths, grep, author, maxCommits, branch } = opts;
+    // Resolve branch first (needed for output metadata).
+    const resolvedBranch = await gitCurrentBranch(top, branch);
+    // Fetch one extra commit to detect truncation.
+    const fetchLimit = maxCommits + 1;
+    const logArgs = [
+        "log",
+        `--pretty=tformat:${PRETTY_FORMAT}`,
+        "--shortstat",
+        `-n`,
+        String(fetchLimit),
+        `--since=${since}`,
+    ];
+    if (branch?.trim()) {
+        logArgs.push(branch.trim());
+    }
+    if (grep?.trim()) {
+        logArgs.push(`--grep=${grep.trim()}`, "-i");
+    }
+    if (author?.trim()) {
+        logArgs.push(`--author=${author.trim()}`);
+    }
+    if (paths.length > 0) {
+        logArgs.push("--", ...paths);
+    }
+    const r = await spawnGitAsync(top, logArgs);
+    if (!r.ok) {
+        return {
+            error: "git_log_failed",
+            path: top,
+        };
+    }
+    // Parse output.
+    // git log --pretty=tformat:%x02<fields>%x01 --shortstat emits, per commit:
+    //   \x02<fields separated by SOH>\x01\n\n <shortstat line>\n
+    // The \x02 is a record-START marker. Splitting on \x02 gives an empty first chunk
+    // followed by one chunk per commit. Each chunk is:
+    //   <fields>\x01\n\n <shortstat>\n
+    const raw = r.stdout;
+    const recordChunks = raw.split(RECORD_SEP_OUT).slice(1); // drop leading empty
+    const allCommits = [];
+    for (const chunk of recordChunks) {
+        if (!chunk.trim())
+            continue;
+        // Fields before the first newline; shortstat (if any) follows blank line.
+        const newlineIdx = chunk.indexOf("\n");
+        const fieldsPart = newlineIdx >= 0 ? chunk.slice(0, newlineIdx) : chunk;
+        const statPart = newlineIdx >= 0 ? chunk.slice(newlineIdx + 1) : "";
+        const fields = fieldsPart.split(FIELD_SEP_OUT);
+        const [sha7, shaFull, subject, authorName, email, date, ageRelative] = fields;
+        if (!sha7 || !shaFull)
+            continue;
+        const stat = parseShortstat(statPart);
+        const commit = {
+            sha7: sha7.trim(),
+            shaFull: shaFull.trim(),
+            subject: subject?.trim() ?? "",
+            author: authorName?.trim() ?? "",
+            email: email?.trim() ?? "",
+            date: date?.trim() ?? "",
+            ageRelative: ageRelative?.trim() ?? "",
+            ...spreadDefined("filesChanged", stat?.filesChanged),
+            ...spreadDefined("insertions", stat?.insertions),
+            ...spreadDefined("deletions", stat?.deletions),
+        };
+        allCommits.push(commit);
+    }
+    const truncated = allCommits.length > maxCommits;
+    const commits = truncated ? allCommits.slice(0, maxCommits) : allCommits;
+    const omittedCount = truncated ? allCommits.length - maxCommits : 0;
+    return {
+        workspace_root: top,
+        repo: basename(top),
+        branch: resolvedBranch,
+        commits,
+        truncated,
+        omittedCount,
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderLogMarkdown(group, filterSummary) {
+    const lines = [];
+    lines.push(`### ${group.repo} (${group.branch})${filterSummary ? `  —  ${filterSummary}` : ""}`);
+    lines.push(`_root: ${group.workspace_root}_`);
+    lines.push("");
+    if (group.commits.length === 0) {
+        lines.push("_(no commits match)_");
+    }
+    else {
+        for (const c of group.commits) {
+            lines.push(`- \`${c.sha7}\`  ${c.ageRelative}  ${c.subject}  —  ${c.author}`);
+        }
+    }
+    if (group.truncated) {
+        lines.push("");
+        lines.push(`_(truncated — ${group.omittedCount} more commit(s) not shown; lower \`since\` or \`maxCommits\`)_`);
+    }
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitLogTool(server) {
+    server.addTool({
+        name: "git_log",
+        description: "Path-filtered, time-windowed read-only `git log` across one or more workspace roots. " +
+            "Returns structured commit history with author, date, subject, and optional diff stats. " +
+            "See docs/mcp-tools.md.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.extend({
+            since: z
+                .string()
+                .optional()
+                .describe("Passed to `git log --since=`. Accepts ISO timestamps or git relative forms like " +
+                "`48.hours` or `2.weeks.ago`. Default: `7.days`."),
+            paths: z
+                .array(z.string())
+                .optional()
+                .describe("Limit to commits touching these paths (passed as `-- <paths>`)."),
+            grep: z
+                .string()
+                .optional()
+                .describe("Filter commits whose message matches this regex (git `--grep`, case-insensitive)."),
+            author: z
+                .string()
+                .optional()
+                .describe("Filter by author name or email (passed as `--author=`)."),
+            maxCommits: z
+                .number()
+                .int()
+                .min(1)
+                .max(MAX_COMMITS_HARD_CAP)
+                .optional()
+                .default(DEFAULT_MAX_COMMITS)
+                .describe(`Maximum commits to return per root (hard cap ${MAX_COMMITS_HARD_CAP}). Default ${DEFAULT_MAX_COMMITS}.`),
+            branch: z.string().optional().describe("Ref/branch to log from. Default: HEAD."),
+        }),
+        execute: async (args) => {
+            const pre = requireGitAndRoots(server, args, undefined);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            // Validate `since` — reject obvious injection attempts (newlines, semicolons, shell chars).
+            const rawSince = (args.since?.trim() ?? DEFAULT_SINCE) || DEFAULT_SINCE;
+            if (/[\n\r;|&`$<>]/.test(rawSince)) {
+                return jsonRespond({ error: "invalid_since", since: rawSince });
+            }
+            // Validate paths — reject anything with null bytes or shell meta.
+            // Use charCodeAt(0) === 0 for the null byte to avoid a biome lint on control chars in regex.
+            const rawPaths = args.paths ?? [];
+            for (const p of rawPaths) {
+                if (p.split("").some((c) => c.charCodeAt(0) === 0) || /[\n\r;|&`$<>]/.test(p)) {
+                    return jsonRespond({ error: "invalid_paths", path: p });
+                }
+            }
+            const maxCommits = Math.min(args.maxCommits ?? DEFAULT_MAX_COMMITS, MAX_COMMITS_HARD_CAP);
+            // Fan out across roots.
+            const jobs = pre.roots.map((rootInput) => ({ rootInput }));
+            const results = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
+                const top = gitTopLevel(rootInput);
+                if (!top) {
+                    return { _error: true, workspace_root: rootInput, error: "not_a_git_repo" };
+                }
+                const r = await runGitLog({
+                    top,
+                    since: rawSince,
+                    paths: rawPaths,
+                    grep: args.grep,
+                    author: args.author,
+                    maxCommits,
+                    branch: args.branch,
+                });
+                if ("error" in r) {
+                    return { _error: true, workspace_root: rootInput, error: r.error };
+                }
+                return { _error: false, ...r };
+            });
+            // Build filter summary string for markdown.
+            const filterParts = [`since: ${rawSince}`];
+            if (rawPaths.length > 0)
+                filterParts.push(`paths: ${rawPaths.join(", ")}`);
+            if (args.grep)
+                filterParts.push(`grep: ${args.grep}`);
+            if (args.author)
+                filterParts.push(`author: ${args.author}`);
+            const filterSummary = filterParts.join(" | ");
+            if (args.format === "json") {
+                const groups = results.map((r) => {
+                    if (r._error) {
+                        return {
+                            workspace_root: r.workspace_root,
+                            repo: basename(r.workspace_root),
+                            branch: "",
+                            commits: [],
+                            ...spreadWhen(true, { error: r.error }),
+                        };
+                    }
+                    const { _error: _e, ...rest } = r;
+                    return {
+                        ...rest,
+                        ...spreadWhen(r.truncated, { truncated: true, omittedCount: r.omittedCount }),
+                    };
+                });
+                return jsonRespond({ groups });
+            }
+            // Markdown
+            const mdChunks = ["# Git log"];
+            for (const r of results) {
+                if (r._error) {
+                    mdChunks.push(`### ${r.workspace_root}\n_error: ${r.error}_`);
+                    continue;
+                }
+                const { _error: _e, ...group } = r;
+                mdChunks.push(renderLogMarkdown(group, filterSummary));
+            }
+            return mdChunks.join("\n\n");
+        },
+    });
+}

package/dist/server/git-parity-tool.js

@@ -8,7 +8,7 @@ import { WorkspacePickSchema } from "./schemas.js";
 export function registerGitParityTool(server) {
     server.addTool({
         name: "git_parity",
-        description: "Read-only: compare `git rev-parse HEAD` for path pairs. Presets or inline `pairs`; `presetMerge` merges with inline pairs.",
+        description: "Read-only HEAD parity for path pairs. See docs/mcp-tools.md.",
         parameters: WorkspacePickSchema.extend({
             pairs: z
                 .array(z.object({
@@ -55,10 +55,7 @@ export function registerGitParityTool(server) {
                     parityPresetSchemaVersion = applied.presetSchemaVersion;
                 }
                 if (!pairs?.length) {
-                    return jsonRespond({
-                        error: "no_pairs",
-                        message: "Pass `pairs` directly or a `preset` with parityPairs (or presetMerge).",
-                    });
+                    return jsonRespond({ error: "no_pairs" });
                 }
                 let allOk = true;
                 const pairResults = [];

package/dist/server/git-status-tool.js

@@ -8,14 +8,9 @@ import { WorkspacePickSchema } from "./schemas.js";
 export function registerGitStatusTool(server) {
     server.addTool({
         name: "git_status",
-        description: "Run `git status --short -b` in the workspace root and (optionally) each path from `.gitmodules`. " +
-            "Read-only. Supports multi-root MCP workspaces via `allWorkspaceRoots` or `rootIndex`.",
+        description: "Read-only `git status --short -b` per root + submodules. See docs/mcp-tools.md.",
         parameters: WorkspacePickSchema.extend({
-            includeSubmodules: z
-                .boolean()
-                .optional()
-                .default(true)
-                .describe("When true (default), include submodule paths listed in .gitmodules."),
+            includeSubmodules: z.boolean().optional().default(true),
         }),
         execute: async (args) => {
             const pre = requireGitAndRoots(server, args, undefined);
@@ -69,13 +64,19 @@ export function registerGitStatusTool(server) {
             if (args.format === "json") {
                 return jsonRespond({ groups });
             }
-            const sections = ["# Multi-root git status", ""];
+            const sections = [groups.length > 1 ? "# Multi-root git status" : "# Git status"];
             for (const g of groups) {
                 if (groups.length > 1) {
-                    sections.push(`### MCP root: ${g.mcpRoot}`, "");
+                    sections.push("", `### MCP root: ${g.mcpRoot}`);
                 }
                 for (const row of g.repos) {
-                    sections.push(`## ${row.label}`, `path: ${row.path}`, "```text", row.statusText || "(empty)", "```", ``);
+                    const body = row.statusText || "(clean)";
+                    if (body.includes("\n")) {
+                        sections.push("", `## ${row.label} — ${row.path}`, "```text", body, "```");
+                    }
+                    else {
+                        sections.push("", `## ${row.label} — ${row.path}`, body);
+                    }
                 }
             }
             return sections.join("\n");

package/dist/server/git.js

@@ -6,7 +6,6 @@ export const GIT_SUBPROCESS_PARALLELISM = 4;
 let gitPathState = "unknown";
 const GIT_NOT_FOUND_BODY = {
     error: "git_not_found",
-    message: "The `git` binary was not found on PATH or failed `git --version`. Install Git and ensure it is available to the MCP server process.",
 };
 export function gateGit() {
     if (gitPathState === "ok") {
@@ -81,22 +80,7 @@ export function isSafeGitUpstreamToken(s) {
         return false;
     if (t.includes(".."))
         return false;
-    if (t.startsWith("-"))
-        return false;
-    if (t.includes("@"))
-        return false;
-    const forbidden = new Set("{}[]~^:?*\\".split(""));
-    for (let i = 0; i < t.length; i++) {
-        const ch = t.charAt(i);
-        const c = ch.charCodeAt(0);
-        if (c < 32 || c === 127)
-            return false;
-        if (/\s/.test(ch))
-            return false;
-        if (forbidden.has(ch))
-            return false;
-    }
-    return true;
+    return /^(?!-)[A-Za-z0-9_./+-]+$/.test(t);
 }
 // ---------------------------------------------------------------------------
 // Async pool for parallel git (inventory)
@@ -140,16 +124,11 @@ function gitStatusFailText(r) {
     return (r.stderr || r.stdout || "git status failed").trim();
 }
 export async function gitStatusSnapshotAsync(cwd) {
-    const [br, sh] = await Promise.all([
-        spawnGitAsync(cwd, ["status", "--short", "-b"]),
-        spawnGitAsync(cwd, ["status", "--short"]),
-    ]);
-    return {
-        branchOk: br.ok,
-        shortOk: sh.ok,
-        branchLine: br.ok ? br.stdout.trimEnd() : gitStatusFailText(br),
-        shortLine: sh.ok ? sh.stdout.trimEnd() : gitStatusFailText(sh),
-    };
+    const r = await spawnGitAsync(cwd, ["status", "--short", "-b"]);
+    if (!r.ok) {
+        return { branchOk: false, branchLine: gitStatusFailText(r) };
+    }
+    return { branchOk: true, branchLine: r.stdout.trimEnd() };
 }
 export async function gitStatusShortBranchAsync(cwd) {
     const s = await gitStatusSnapshotAsync(cwd);