@herbertgao/pi-extensions 2026.8.6 → 2026.8.7

package/node_modules/pi-lens/dist/clients/agent-nudge.js

@@ -68,12 +68,17 @@ function recordTouchedEvent(payload, getReadGuard) {
             // recorded via the cross-process feed, now also reported by this
             // session's own bus, upgrades to "local".
             existing.origin = "local";
+            // #1464: a fresh touch invalidates any content already delivered for
+            // this path (the default deferred format at agent_end, a cascade
+            // autofix) — those bytes no longer describe the file.
+            existing.contentDelivered = false;
         }
         else {
             _touched.set(mapKey, {
                 displayPath: rawPath,
                 reasons: new Set([payload.reason]),
                 origin: "local",
+                contentDelivered: false,
             });
         }
     }
@@ -112,16 +117,47 @@ export function recordCrossProcessTouches(entries) {
             existing.reasons.add(entry.reason);
             // "local" is sticky (see AccumulatedFileOrigin) — never downgrade an
             // already-local entry back to cross-process.
+            // #1464: a foreign process touching this file invalidates whatever
+            // content this session's write path already delivered for it.
+            existing.contentDelivered = false;
         }
         else {
             _touched.set(mapKey, {
                 displayPath: entry.path,
                 reasons: new Set([entry.reason]),
                 origin: "cross-process",
+                contentDelivered: false,
             });
         }
     }
 }
+/**
+ * Record the write path's authoritative-content attachment outcome for one
+ * path (#1464).
+ *
+ * `attached` is the SAME boolean that drove the attachment in
+ * `handleToolResult` (clients/runtime-tool-result.ts) — this module never
+ * re-derives it from config, byte counts, or the aggregate budget. `true`
+ * means the post-fix bytes went out in the write's own tool result and the
+ * agent already holds them, so "re-read before editing" is noise. `false` is
+ * the size cap and the per-command aggregate budget degrading an attachment
+ * to a re-read warning: there the nudge is the whole signal, and calling this
+ * with `false` re-arms a path an earlier per-file decision had suppressed
+ * (the bash multi-file case, where the outer budget loop overrides the inner
+ * per-file "attached").
+ *
+ * Marks an EXISTING accumulator entry only. `publishFilesTouched` fires
+ * synchronously inside the `runPipeline` call this decision belongs to (pi's
+ * event bus is a plain `EventEmitter`), so the entry is already there for any
+ * path the relevance filter admitted; a path with no entry has nothing to
+ * suppress. Deferred-edit autofix at `agent_end` never reaches here — it
+ * attaches nothing, so it keeps nudging.
+ */
+export function noteAuthoritativeContentAttachment(filePath, attached) {
+    const entry = _touched.get(normalizeMapKey(filePath));
+    if (entry)
+        entry.contentDelivered = attached;
+}
 /**
  * Subscribe to `pilens:files:touched` on pi's shared event bus. Called once
  * at extension factory time from index.ts, mirroring `wireBusEmitter`'s
@@ -191,17 +227,29 @@ export function wireAgentNudgeSubscriber(args) {
  * very first call of a fresh `agent_start` — so the accumulator surviving
  * across run boundaries is exactly what makes that cross-run delivery work.
  * Empty accumulator ⇒ returns undefined ⇒ zero bytes injected.
+ *
+ * #1464: paths whose post-fix content the write path already attached to its
+ * OWN tool result are dropped from the batch here (see
+ * `noteAuthoritativeContentAttachment`) — the agent holds those bytes, so
+ * "re-read before editing" would spend context to re-fetch what it has. A
+ * batch that is ENTIRELY such paths injects nothing.
  */
 export function consumeAgentNudge(dbg) {
-    const entries = Array.from(_touched.values());
+    const drained = Array.from(_touched.values());
     _touched.clear();
     const filesFiltered = _relevanceFilteredCount;
     _relevanceFilteredCount = 0;
     if (!isAgentNudgeEnabled())
         return undefined;
-    if (entries.length === 0)
+    if (drained.length === 0)
         return undefined;
     try {
+        // #1464: a write whose post-fix bytes were attached to its own tool
+        // result already told the agent everything this nudge would. Drop those
+        // paths from the message but keep counting them, so over-suppression is
+        // visible in telemetry instead of only in the absence of complaints.
+        const entries = drained.filter((e) => !e.contentDelivered);
+        const filesContentDelivered = drained.length - entries.length;
         const filesTotal = entries.length;
         const shown = entries.slice(0, MAX_NAMES_SHOWN);
         const remaining = filesTotal - shown.length;
@@ -225,15 +273,6 @@ export function consumeAgentNudge(dbg) {
             : names.join(", ");
         const crossProcessCount = entries.filter((e) => e.origin === "cross-process").length;
         const localCount = filesTotal - crossProcessCount;
-        // Three-way attribution (see the function doc): never assign a local
-        // file to another instance — a mixed batch keeps the local base framing
-        // and calls out the cross-process portion by exact count.
-        const attribution = localCount === 0
-            ? "by an automatic run outside your turn"
-            : crossProcessCount === 0
-                ? "after your last turn"
-                : `after your last turn (${crossProcessCount} of them by an automatic run outside it)`;
-        const message = `pi-lens: ${filesTotal} file(s) were ${verbLabel} ${attribution}: ${nameList} — working-tree changes to these are expected; re-read before editing.`;
         logLatency({
             type: "phase",
             filePath: "<pi-lens>",
@@ -246,6 +285,10 @@ export function consumeAgentNudge(dbg) {
                 // never read/edited) — NOT the display overflow, which is
                 // filesTotal - filesShown.
                 filesFiltered,
+                // #1464: drops because the write's own tool result already carried
+                // the post-fix bytes. A third, distinct count: these paths passed
+                // the relevance filter and were accumulated, then suppressed here.
+                filesContentDelivered,
                 reasonMix: Array.from(allReasons),
                 // #492: origin mix so cross-process pickup rate is observable
                 // alongside the existing relevance-filter metric.
@@ -253,6 +296,19 @@ export function consumeAgentNudge(dbg) {
                 originCrossProcess: crossProcessCount,
             },
         });
+        // Everything drained was delivered in a write's own tool result — the
+        // row above records that it happened, and zero bytes get injected.
+        if (filesTotal === 0)
+            return undefined;
+        // Three-way attribution (see the function doc): never assign a local
+        // file to another instance — a mixed batch keeps the local base framing
+        // and calls out the cross-process portion by exact count.
+        const attribution = localCount === 0
+            ? "by an automatic run outside your turn"
+            : crossProcessCount === 0
+                ? "after your last turn"
+                : `after your last turn (${crossProcessCount} of them by an automatic run outside it)`;
+        const message = `pi-lens: ${filesTotal} file(s) were ${verbLabel} ${attribution}: ${nameList} — working-tree changes to these are expected; re-read before editing.`;
         return {
             messages: [
                 {

package/node_modules/pi-lens/dist/clients/ast-grep-client.js

@@ -176,9 +176,12 @@ export class AstGrepClient {
      * Each path is scanned independently; results are merged.
      */
     async tempScanDetailed(dir, ruleYaml, options = {}) {
-        // Keep tests and older embedders that replace the runner with the historic
-        // match-only seam working. The production SgRunner always has the detailed
-        // method, so failures cannot be mistaken for an empty result there.
+        // SAFETY: keep tests and older embedders that replace the runner with the
+        // historic match-only seam working. The cast only makes
+        // `tempScanDetailedAsync` OPTIONAL on the runner surface — it claims
+        // nothing about the method existing. The call site below checks for it
+        // before invoking, and the production SgRunner always has it, so a
+        // failure there cannot be mistaken for an empty result.
         const detailed = this.runner.tempScanDetailedAsync;
         if (detailed) {
             return detailed.call(this.runner, dir, "agent-rule", ruleYaml, 30_000, options);
@@ -568,12 +571,15 @@ message: found
             return "";
         const errors = diags.filter((d) => d.severity === "error");
         const warnings = diags.filter((d) => d.severity === "warning");
+        const infos = diags.filter((d) => d.severity === "info");
         const hints = diags.filter((d) => d.severity === "hint");
         let output = `[ast-grep] ${diags.length} structural issue(s)`;
         if (errors.length)
             output += ` — ${errors.length} error(s)`;
         if (warnings.length)
             output += ` — ${warnings.length} warning(s)`;
+        if (infos.length)
+            output += ` — ${infos.length} info(s)`;
         if (hints.length)
             output += ` — ${hints.length} hint(s)`;
         output += ":\n";

package/node_modules/pi-lens/dist/clients/atomic-write.js

@@ -38,7 +38,7 @@
  *     cycles still lose updates: each writer publishes the state it computed
  *     from the snapshot it read, and last-rename-wins silently discards the
  *     other's mutation. Callers needing this must serialize themselves (see
- *     `lspChildRemovalTail` in `instance-registry.ts`).
+ *     `registryChildMutationTail` in `instance-registry.ts`).
  *   - **No ordering.** Nothing sequences concurrent writers, within or across
  *     processes. The winner is whichever `rename` lands last, which is not
  *     necessarily the write that started or finished last.
@@ -143,7 +143,10 @@ export function writeFileAtomic(targetPath, data, options) {
     const bestEffort = options?.bestEffort ?? true;
     const tmpPath = stagePathFor(targetPath);
     try {
-        fs.writeFileSync(tmpPath, data, typeof data === "string" ? "utf-8" : undefined);
+        fs.writeFileSync(tmpPath, data, {
+            encoding: typeof data === "string" ? "utf-8" : undefined,
+            mode: options?.mode,
+        });
         fs.renameSync(tmpPath, targetPath);
     }
     catch (err) {
@@ -167,7 +170,10 @@ export async function writeFileAtomicAsync(targetPath, data, options) {
     const bestEffort = options?.bestEffort ?? true;
     const tmpPath = stagePathFor(targetPath);
     try {
-        await fs.promises.writeFile(tmpPath, data, typeof data === "string" ? "utf-8" : undefined);
+        await fs.promises.writeFile(tmpPath, data, {
+            encoding: typeof data === "string" ? "utf-8" : undefined,
+            mode: options?.mode,
+        });
         await fs.promises.rename(tmpPath, targetPath);
     }
     catch (err) {

package/node_modules/pi-lens/dist/clients/bash-file-access.js

@@ -4,7 +4,8 @@
  *
  *   - VIEW commands (cat/head/tail/sed -n) → reads, recorded with the exact line
  *     range shown (like the Read tool's delivered range).
- *   - WRITE commands (redirects, tee, sed -i, cp/mv dest, touch) → the agent
+ *   - WRITE commands (redirects, tee, sed -i, cp/mv dest, touch, and explicit
+ *     in-place formatter/fixer targets) → the agent
  *     authored/owns the resulting file, exactly like the Write tool — these are
  *     registered via noteCreatedFile + recordWritten so a follow-up edit is not
  *     blocked.
@@ -90,7 +91,7 @@ export function tokenizeShellCommand(command) {
             // Windows routinely contain native paths (C:\\src\\file.ts). Preserve
             // backslashes before ordinary path characters while still honoring
             // shell escapes and line continuations.
-            if (next === "\n" || /[\s\\'\";$|&<>]/.test(next ?? "")) {
+            if (next === "\n" || /[\s\\'";$|&<>]/.test(next ?? "")) {
                 escaped = true;
             }
             else {
@@ -162,6 +163,37 @@ function parseCountFlag(token) {
 function commandSegments(command) {
     return tokenizeShellCommand(command).map((segment) => segment.tokens);
 }
+/** Unwrap the common agent-authored `npx <tool>` launcher form. */
+function unwrapCommand(tokens) {
+    let verb = path.basename(tokens[0] ?? "");
+    let args = tokens.slice(1);
+    if (verb === "npx") {
+        while (args[0] === "-y" || args[0] === "--yes")
+            args = args.slice(1);
+        verb = path.basename(args[0] ?? "");
+        args = args.slice(1);
+    }
+    return { verb, args };
+}
+/**
+ * Return source-file operands while excluding values consumed by known options.
+ * This stays deliberately narrower than a general CLI parser: only formatter
+ * options whose values can themselves look like source files belong here.
+ */
+function formatterFileArgs(args, start = 0, valueOptions = new Set()) {
+    const files = [];
+    for (let i = start; i < args.length; i += 1) {
+        const arg = args[i] ?? "";
+        if (valueOptions.has(arg)) {
+            i += 1;
+            continue;
+        }
+        if (arg === "--" || arg.startsWith("-"))
+            continue;
+        files.push(arg);
+    }
+    return files;
+}
 /** Find redirect targets without treating quoted `>` characters as syntax. */
 function extractRedirectTargets(command) {
     const targets = [];
@@ -344,6 +376,80 @@ const GREP_OPTIONS_WITH_VALUE = new Set([
     "--before-context",
     "--context",
 ]);
+function parseContextValue(inline, next) {
+    const raw = inline !== "" ? inline : next;
+    if (raw === undefined)
+        return undefined;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0)
+        return undefined;
+    // Bound the credit: a huge -C would credit a whole file from one hit.
+    return Math.min(n, 100);
+}
+/**
+ * Read the context lines a `grep` invocation actually PRINTS around each hit
+ * (#1904 item 2). Only these lines were delivered to the model, so only these
+ * may be credited as read. Handles `-A N`, `-A3`, clustered short flags such as
+ * `-rnA3`, `--after-context=N`, the `-B`/`--before-context` mirror, `-C`
+ * (both sides), and the bare `-NUM` form.
+ */
+export function parseGrepContextLines(args) {
+    let before = 0;
+    let after = 0;
+    for (let i = 0; i < args.length; i++) {
+        const token = stripQuotes(args[i]);
+        if (token === "--")
+            break;
+        const nextToken = args[i + 1] === undefined ? undefined : stripQuotes(args[i + 1]);
+        const long = /^--(after|before)-context(?:=(\d+))?$/.exec(token);
+        if (long) {
+            const value = parseContextValue(long[2] ?? "", nextToken);
+            if (value === undefined)
+                continue;
+            if (long[1] === "after")
+                after = Math.max(after, value);
+            else
+                before = Math.max(before, value);
+            continue;
+        }
+        const longBoth = /^--context(?:=(\d+))?$/.exec(token);
+        if (longBoth) {
+            const value = parseContextValue(longBoth[1] ?? "", nextToken);
+            if (value === undefined)
+                continue;
+            before = Math.max(before, value);
+            after = Math.max(after, value);
+            continue;
+        }
+        // Bare numeric context form: `grep -3 pattern file`.
+        const bare = /^-(\d+)$/.exec(token);
+        if (bare) {
+            const value = parseContextValue(bare[1], undefined);
+            if (value === undefined)
+                continue;
+            before = Math.max(before, value);
+            after = Math.max(after, value);
+            continue;
+        }
+        // Short flags, possibly clustered: the context flag must be LAST in the
+        // cluster because it consumes the remaining characters as its value.
+        const short = /^-[A-Za-z]*([ABC])(\d*)$/.exec(token);
+        if (!short)
+            continue;
+        const value = parseContextValue(short[2], nextToken);
+        if (value === undefined)
+            continue;
+        if (short[1] === "A")
+            after = Math.max(after, value);
+        else if (short[1] === "B")
+            before = Math.max(before, value);
+        else {
+            before = Math.max(before, value);
+            after = Math.max(after, value);
+        }
+    }
+    return { before, after };
+}
 function extractGrepSearchFiles(args, cwd) {
     const files = [];
     let patternSeen = false;
@@ -411,6 +517,11 @@ function parseGrepLineWithoutFile(line, file) {
 function collectGrepCommandFiles(command, cwd) {
     const files = new Set();
     let hasLineNumberGrep = false;
+    // A command can chain several greps whose output all reaches the model, but
+    // the parsed hits carry no segment identity. Credit the SMALLEST context any
+    // contributing grep printed, so no line is credited that a hit from the
+    // narrowest grep never delivered.
+    let context;
     for (const tokens of commandSegments(command)) {
         const verb = path.basename(stripQuotes(tokens[0] ?? ""));
         if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
@@ -419,10 +530,21 @@ function collectGrepCommandFiles(command, cwd) {
         if (!grepHasLineNumbers(args))
             continue;
         hasLineNumberGrep = true;
+        const segmentContext = parseGrepContextLines(args);
+        context = context
+            ? {
+                before: Math.min(context.before, segmentContext.before),
+                after: Math.min(context.after, segmentContext.after),
+            }
+            : segmentContext;
         for (const file of extractGrepSearchFiles(args, cwd))
             files.add(file);
     }
-    return { hasLineNumberGrep, files };
+    return {
+        hasLineNumberGrep,
+        files,
+        context: context ?? { before: 0, after: 0 },
+    };
 }
 function dedupePushSearchRead(out, seen, loc) {
     if (!loc)
@@ -452,17 +574,25 @@ function parseGrepOutputSearchReads(output, cwd, singleFile) {
  * so the latter is only accepted when the command names exactly one source file.
  */
 export function extractGrepSearchReadsFromOutput(command, cwd, output) {
-    const { hasLineNumberGrep, files } = collectGrepCommandFiles(command, cwd);
+    const { hasLineNumberGrep, files, context } = collectGrepCommandFiles(command, cwd);
     if (!hasLineNumberGrep)
         return [];
     const singleFile = files.size === 1 ? [...files][0] : undefined;
-    return parseGrepOutputSearchReads(output, cwd, singleFile);
+    const locations = parseGrepOutputSearchReads(output, cwd, singleFile);
+    // Only the printed context lines were delivered to the model, so only they
+    // are credited. A bare grep credits its match line alone (#1904 item 2).
+    for (const loc of locations) {
+        loc.contextBefore = context.before;
+        loc.contextAfter = context.after;
+    }
+    return locations;
 }
 /**
  * Extract files a bash command WROTE/created, so the read-guard can treat them
  * as authored by the agent (mirrors the Write tool). Handles:
  *   redirects: `> FILE`, `>> FILE`, `N> FILE`, `&> FILE` (with or without space)
- *   tee [-a] FILE...,  sed -i ... FILE,  cp/mv/install ... DEST,  touch FILE...
+ *   tee [-a] FILE..., sed -i ... FILE, cp/mv/install ... DEST, touch FILE...,
+ *   and common in-place formatter/fixer invocations with explicit file targets.
  *
  * Returns absolute paths. The file need not exist yet (it may be created) —
  * existence is confirmed later by recordWritten at tool_result time.
@@ -490,8 +620,7 @@ export function extractWrittenPathsFromCommand(command, cwd) {
     for (const tokens of commandSegments(command)) {
         if (tokens.length === 0)
             continue;
-        const verb = path.basename(tokens[0] ?? "");
-        const args = tokens.slice(1);
+        const { verb, args } = unwrapCommand(tokens);
         if (verb === "tee" || verb === "touch") {
             for (const a of args)
                 if (!a.startsWith("-"))
@@ -502,10 +631,89 @@ export function extractWrittenPathsFromCommand(command, cwd) {
                 add(a);
         }
         else if (verb === "cp" || verb === "mv" || verb === "install") {
+            // Known miss (#1668 review F3): the GNU `-t DEST`/`--target-directory`
+            // form puts the destination BEFORE the sources — this always treats
+            // the LAST non-flag argument as the destination, so `-t DEST SRC` and
+            // multi-source `-t DEST SRC1 SRC2...` are misread. Rare in agent-
+            // authored bash (source-before-dest is the common form); documented
+            // rather than fixed, since correctly parsing `-t` means recognizing it
+            // takes a value while telling it apart from every other single-letter
+            // flag this same branch already ignores.
             const files = args.filter((a) => !a.startsWith("-"));
             if (files.length >= 1)
                 add(files[files.length - 1]); // destination
         }
+        else if (verb === "biome") {
+            const sub = args[0];
+            if ((sub === "format" || sub === "check") && args.includes("--write")) {
+                for (const file of formatterFileArgs(args, 1, new Set(["--config-path"])))
+                    add(file);
+            }
+        }
+        else if (verb === "prettier" && args.includes("--write")) {
+            for (const file of formatterFileArgs(args, 0, new Set(["--config", "--ignore-path", "--parser", "--plugin"])))
+                add(file);
+        }
+        else if (verb === "eslint" && args.includes("--fix")) {
+            for (const file of formatterFileArgs(args, 0, new Set(["--config", "--ignore-path", "--parser", "--plugin"])))
+                add(file);
+        }
+        else if (verb === "ruff") {
+            const sub = args[0];
+            if (sub === "format" || args.includes("--fix")) {
+                const start = sub === "format" || sub === "check" ? 1 : 0;
+                for (const file of formatterFileArgs(args, start, new Set(["--config"])))
+                    add(file);
+            }
+        }
+        else if (verb === "gofmt" && args.includes("-w")) {
+            for (const file of formatterFileArgs(args))
+                add(file);
+        }
+        else if (verb === "cargo" && args[0] === "fmt") {
+            // Bare cargo fmt is project-scoped and cannot be enumerated without a
+            // filesystem walk. Only explicit rustfmt operands after `--` are safe.
+            const separator = args.indexOf("--");
+            if (separator >= 0) {
+                for (const file of formatterFileArgs(args, separator + 1, new Set(["--edition", "--config-path"])))
+                    add(file);
+            }
+        }
+        else if (verb === "rustfmt") {
+            for (const file of formatterFileArgs(args, 0, new Set(["--edition", "--config-path"])))
+                add(file);
+        }
+        else if (verb === "black") {
+            for (const file of formatterFileArgs(args, 0, new Set([
+                "--config",
+                "--exclude",
+                "--include",
+                "--line-length",
+                "--target-version",
+            ])))
+                add(file);
+        }
+        else if (verb === "clang-format" && args.includes("-i")) {
+            for (const file of formatterFileArgs(args, 0, new Set(["--style", "--fallback-style", "--assume-filename"])))
+                add(file);
+        }
+        else if (verb === "dotnet" && args[0] === "format") {
+            // dotnet format is normally solution-scoped. `--include` is the one
+            // invocation form that provides attributable source paths.
+            for (let i = 1; i < args.length; i += 1) {
+                if (args[i] === "--include" && args[i + 1]) {
+                    for (const file of (args[i + 1] ?? "").split(","))
+                        add(file);
+                    i += 1;
+                }
+                else if (args[i]?.startsWith("--include=")) {
+                    for (const file of (args[i] ?? "")
+                        .slice("--include=".length)
+                        .split(","))
+                        add(file);
+                }
+            }
+        }
         else if (verb === "git") {
             // git ops that REWRITE working-tree files with explicit paths:
             //   git checkout [<ref>] -- <files>   git restore [opts] <files>
@@ -524,6 +732,75 @@ export function extractWrittenPathsFromCommand(command, cwd) {
                 for (const a of fileArgs)
                     add(a);
             }
+            else if (sub === "mv") {
+                // git mv SRC... DEST — the destination is a write, exactly like
+                // plain `mv` above (#1668 review F2). The source side is a delete,
+                // handled by extractDeletedPathsFromCommand.
+                const files = args.slice(1).filter((a) => !a.startsWith("-"));
+                if (files.length >= 1)
+                    add(files[files.length - 1]);
+            }
+        }
+    }
+    return Array.from(out);
+}
+/**
+ * Extract files a bash command likely DELETED, for the type-3 (Deleted)
+ * watched-files gap (#1668): `rm FILE...`, `git rm FILE...`, and the SOURCE
+ * side of `mv SRC DEST` / `git mv SRC DEST` (the destination is a write,
+ * covered by `extractWrittenPathsFromCommand` — including for `git mv`,
+ * #1668 review F2).
+ *
+ * Deliberately narrow: only commands naming an explicit file target are
+ * handled. A bare directory op (`rm -rf dir/`, `git clean`) is skipped —
+ * resolving what vanished inside a directory would mean listing it before
+ * and after, the "stat the world" cost this module exists to avoid. The
+ * caller confirms each candidate by checking it no longer exists on disk;
+ * this function only proposes what the command named.
+ */
+export function extractDeletedPathsFromCommand(command, cwd) {
+    const out = new Set();
+    const add = (token) => {
+        const abs = resolveCandidate(token, cwd);
+        if (abs)
+            out.add(abs);
+    };
+    // mv SRC... DEST / git mv SRC... DEST — every argument except the last is
+    // a source that vanishes from its original path once the move lands.
+    // Known miss (#1668 review F3): the same `-t DEST`/`--target-directory`
+    // form documented in `extractWrittenPathsFromCommand` misreads here too —
+    // this assumes source-before-destination order.
+    const addMoveSources = (args) => {
+        const files = args.filter((a) => !a.startsWith("-"));
+        if (files.length >= 2) {
+            for (const src of files.slice(0, -1))
+                add(src);
+        }
+    };
+    for (const tokens of commandSegments(command)) {
+        if (tokens.length === 0)
+            continue;
+        const verb = path.basename(tokens[0] ?? "");
+        const args = tokens.slice(1);
+        if (verb === "rm") {
+            for (const a of args)
+                if (!a.startsWith("-"))
+                    add(a);
+        }
+        else if (verb === "git" && args[0] === "rm") {
+            const rmArgs = args.slice(1);
+            const dashDash = rmArgs.indexOf("--");
+            const fileArgs = dashDash >= 0
+                ? rmArgs.slice(dashDash + 1)
+                : rmArgs.filter((a) => !a.startsWith("-"));
+            for (const a of fileArgs)
+                add(a);
+        }
+        else if (verb === "git" && args[0] === "mv") {
+            addMoveSources(args.slice(1));
+        }
+        else if (verb === "mv") {
+            addMoveSources(args);
         }
     }
     return Array.from(out);