@adhisang/minecraft-modding-mcp 7.1.0 → 7.1.1

package/dist/stdio-supervisor.js

@@ -670,6 +670,15 @@ export class StdioSupervisor {
     unresolvedTreeTokens = new Set();
     restartBackoff = new RestartBackoffState();
     terminalChildren = new WeakSet();
+    /**
+     * Workers started by the DEFAULT spawner on POSIX, which spawns them
+     * detached — so each one leads its own process group and `-pid` names
+     * exactly that group. Only these are group-signalled after an unexpected
+     * exit: a child handed in by an injected spawner carries no such guarantee,
+     * and its pid may not be a group id this supervisor owns.
+     */
+    processGroupLeaders = new WeakSet();
+    spawnsProcessGroupLeaders;
     /**
      * Monotonic worker-generation counter (incremented per successful spawn).
      * Recorded into finality tombstones so retention can be bounded per
@@ -776,7 +785,8 @@ export class StdioSupervisor {
      * Number of queued requests that arrived before an initial initialize while
      * the worker was unavailable. Only era-neutral modern discovers can occupy
      * this prefix; readiness forwards it before initialize, then keeps the queue
-     * suffix gated until the initialization response.
+     * suffix gated until the initialization response. A RE-initialize (the era
+     * is already legacy) has no prefix at all: nothing queued may overtake it.
      */
     initializePredecessorCount = 0;
     clientInitialized = false;
@@ -818,6 +828,7 @@ export class StdioSupervisor {
         this.monotonicNow = options.monotonicNow ?? (() => performance.now());
         this.timerScheduler = options.timerScheduler ?? ((callback, delayMs) => setTimeout(callback, delayMs));
         this.timerClearer = options.timerClearer ?? ((timer) => clearTimeout(timer));
+        this.spawnsProcessGroupLeaders = options.workerSpawner === undefined && process.platform !== "win32";
         this.workerSpawner = options.workerSpawner ?? (() => spawn(process.execPath, [...process.execArgv, this.entryFile], {
             env: {
                 ...process.env,
@@ -1246,6 +1257,7 @@ export class StdioSupervisor {
                 this.writeToClient(buildInvalidInitializeRejection(message.id), this.modeForMessage(message));
                 return;
             }
+            const eraBeforeInitialize = this.era;
             this.era = "legacy";
             // The SDK's opening classifier treats an initialize that carries a
             // valid modern era claim as MODERN, diverging from this admission rule
@@ -1270,7 +1282,13 @@ export class StdioSupervisor {
                 this.forwardRequest(message, this.createPendingRequest(message));
             }
             else {
-                this.initializePredecessorCount = this.queuedRequests.length;
+                // Only an INITIAL initialize owns a releasable prefix: while the era
+                // was unselected the sole request that can have queued is an
+                // era-neutral discover. Once legacy is locked ordinary requests queue
+                // too, and letting them overtake a RE-sent initialize would hand them
+                // to an un-handshaken replacement worker.
+                this.initializePredecessorCount =
+                    eraBeforeInitialize === "unselected" ? this.queuedRequests.length : 0;
                 const existing = this.queuedNotifications.findIndex((entry) => isRequest(entry) && entry.method === "initialize");
                 if (existing >= 0)
                     this.queuedNotifications.splice(existing, 1);
@@ -2009,6 +2027,8 @@ export class StdioSupervisor {
         }
         this.child = child;
         this.liveChildren.add(child);
+        if (this.spawnsProcessGroupLeaders)
+            this.processGroupLeaders.add(child);
         this.workerReaders.set(child, new JsonRpcFrameReader());
         const generation = ++this.workerGeneration;
         // "close" fires only once the process has ended AND its stdio streams are
@@ -2407,6 +2427,10 @@ export class StdioSupervisor {
         const wasReady = this.childReady;
         const readyAt = this.childReadyAt;
         this.detachCurrentChild();
+        // The worker ended on its own (crash, OOM, an external kill of the worker
+        // alone): no supervisor-initiated termination ran, so any descendant it
+        // forked is still alive in its process group with no other owner.
+        this.reapExitedWorkerGroup(child, childPid);
         if (this.shuttingDown) {
             return;
         }
@@ -2925,6 +2949,57 @@ export class StdioSupervisor {
             child.stdin.removeAllListeners("error");
         }
     }
+    /**
+     * Signals the process group of a worker that exited UNEXPECTEDLY, so the
+     * descendants it leaves behind (a Java grandchild above all) are not
+     * orphaned.
+     *
+     * PID reuse: this runs from the worker's `exit` event, after the worker
+     * itself was reaped, so its pid is free again. The kernel still refuses to
+     * hand that number out as a new pid or pgid while ANY member of the old
+     * group is alive — so while there is something left to reap, `-pid` names
+     * exactly that group. The residual race (the group already empty AND the
+     * number reused by a new group leader in between) is accepted as negligible.
+     * pidfd-based group signalling would close it but needs Linux 6.9+.
+     *
+     * Fire-and-forget by design: it is not recorded as an in-flight cleanup, so
+     * it never occupies a live-generation slot or delays the replacement.
+     *
+     * Windows: `taskkill /T` walks the tree from its root, and the root has
+     * already exited here, so there is nothing it can find. Descendants of a
+     * crashed worker are not reaped on Windows (known limitation).
+     *
+     * Logged `result`: "signalled" (the group had members and was signalled),
+     * "group-empty" (ESRCH — nothing was left), or "failed".
+     */
+    reapExitedWorkerGroup(child, pid) {
+        if (pid === undefined)
+            return;
+        const report = (result) => {
+            this.eventWriter(result === "failed" ? "warn" : "info", "supervisor.worker_exit_group_cleanup", {
+                pid,
+                result
+            });
+        };
+        if (process.platform === "win32") {
+            debugSupervisor("worker_exit_group_unreachable", { pid });
+            return;
+        }
+        if (!this.processGroupLeaders.has(child))
+            return;
+        let groupEmpty = false;
+        const signalled = terminatePosixProcessGroup(pid, (target, signal) => {
+            try {
+                process.kill(target, signal);
+            }
+            catch (error) {
+                if (error?.code === "ESRCH")
+                    groupEmpty = true;
+                throw error;
+            }
+        });
+        report(!signalled ? "failed" : groupEmpty ? "group-empty" : "signalled");
+    }
     recoverTimedOutWorker() {
         const child = this.child;
         if (!child) {

package/dist/storage/files-repo.d.ts

@@ -19,6 +19,13 @@ export interface SearchFilesOptions {
     cursor?: string;
     mode?: "mixed" | "text" | "path";
     fetchLimitOverride?: number;
+    /**
+     * Literal file_path prefix (e.g. `net/minecraft/`) that narrows the candidate
+     * queries through an escaped, ASCII case-insensitive `LIKE prefix%`. That match
+     * set is a superset of a case-sensitive startsWith, so callers keep their own
+     * exact scope check on the returned candidates.
+     */
+    pathPrefix?: string;
 }
 export interface SearchFilesResult {
     filePath: string;

package/dist/storage/files-repo.js

@@ -108,6 +108,15 @@ function buildPreview(content, query) {
 function tokenizeIndexedQuery(query) {
     return query.match(/[\p{L}\p{N}]+/gu) ?? [];
 }
+/**
+ * Quote a token so FTS5 reads it as a string literal instead of grammar. Real
+ * Minecraft identifiers tokenize into operator keywords (`BooleanOp.AND` ->
+ * `BooleanOp AND`), which unquoted is either a syntax error or - mid-query, as
+ * in `a NOT b` - a silent change of meaning.
+ */
+function quoteIndexedToken(token) {
+    return `"${token.replace(/"/g, '""')}"`;
+}
 function buildIndexedMatchQuery(query, match) {
     const tokens = tokenizeIndexedQuery(query.trim());
     if (tokens.length === 0) {
@@ -118,10 +127,11 @@ function buildIndexedMatchQuery(query, match) {
     // path while SourceService re-checks hydrated path/content matches before
     // returning hits. Callers can still use literal mode for exact substring scans.
     return tokens.map((token, index) => {
+        const quoted = quoteIndexedToken(token);
         if (match === "prefix" && index === tokens.length - 1) {
-            return `${token}*`;
+            return `${quoted}*`;
         }
-        return token;
+        return quoted;
     }).join(" ");
 }
 /** Escape LIKE wildcards so the needle is matched literally under ESCAPE '\'. */
@@ -177,6 +187,7 @@ export class FilesRepo {
       SELECT file_path
       FROM files
       WHERE artifact_id = ? AND file_path LIKE ? ESCAPE '\\'
+        AND (? IS NULL OR file_path LIKE ? ESCAPE '\\')
       ORDER BY file_path ASC
       LIMIT ?
     `);
@@ -191,6 +202,7 @@ export class FilesRepo {
       SELECT file_path, rank
       FROM files_fts
       WHERE artifact_id = ? AND files_fts MATCH ?
+        AND (? IS NULL OR file_path LIKE ? ESCAPE '\\')
       ORDER BY rank
       LIMIT ?
     `);
@@ -314,6 +326,7 @@ export class FilesRepo {
         const cursor = parseSearchCursor(options.cursor);
         const likeQuery = `%${escapeLikeNeedle(normalized)}%`;
         const ftsQuery = buildIndexedMatchQuery(normalized, options.match);
+        const scopePattern = options.pathPrefix ? `${escapeLikeNeedle(options.pathPrefix)}%` : null;
         const mode = options.mode ?? "mixed";
         // Cursor-adaptive fetch limit: when no cursor, use a generous limit;
         // with cursor + SQL pushdown, we need far fewer rows.
@@ -325,7 +338,7 @@ export class FilesRepo {
         const includePath = mode !== "text" && !cursorExhausted;
         const includeContent = mode !== "path" && !cursorExhausted;
         const pathRows = includePath
-            ? this.searchPathStmt.all(artifactId, likeQuery, fetchLimit)
+            ? this.searchPathStmt.all(artifactId, likeQuery, scopePattern, scopePattern, fetchLimit)
             : [];
         const merged = pathRows.map((row) => ({
             filePath: row.file_path,
@@ -336,7 +349,7 @@ export class FilesRepo {
         let contentRows = [];
         if (includeContent && ftsQuery) {
             try {
-                contentRows = this.searchFtsStmt.all(artifactId, ftsQuery, fetchLimit);
+                contentRows = this.searchFtsStmt.all(artifactId, ftsQuery, scopePattern, scopePattern, fetchLimit);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);

package/dist/tool-contract-manifest.js

@@ -17,7 +17,7 @@ const SECTION_ROWS = {
             "| `compare-minecraft` | Compare version pairs, class diffs, registry diffs, and migration-oriented summaries |",
             "| `analyze-mod` | Summarize mod metadata, decompile and search mod code, inspect class source, read class members from bytecode, and preview or apply remaps |",
             "| `validate-project` | Summarize workspaces and run direct Mixin, Access Widener, or Access Transformer validation |",
-            "| `manage-cache` | List, verify, and preview or apply cache cleanup and rebuild operations |"
+            "| `manage-cache` | List, verify, and preview or apply cache cleanup operations |"
         ],
         ja: [
             "| `inspect-minecraft` | バージョン、アーティファクト、クラス、ファイル、ソース本文、ワークスペース文脈の調査フローをまとめて扱う |",
@@ -25,7 +25,7 @@ const SECTION_ROWS = {
             "| `compare-minecraft` | バージョン差分、クラス差分、レジストリ差分、移行向け概要を比較する |",
             "| `analyze-mod` | Mod メタデータの要約、Mod コードのデコンパイル / 検索、クラスソース確認、リマップのプレビュー / 実行を扱う |",
             "| `validate-project` | ワークスペース要約と、Mixin / Access Widener / Access Transformer の直接検証を行う |",
-            "| `manage-cache` | キャッシュの一覧、検証、クリーンアップ / 再構築のプレビュー / 実行を行う |"
+            "| `manage-cache` | キャッシュの一覧、検証、クリーンアップのプレビュー / 実行を行う |"
         ]
     },
     "source-exploration": {

package/dist/tool-execution-gate.js

@@ -4,7 +4,8 @@ const DEFAULT_OPTIONS = {
     maxQueue: 2
 };
 // Heavy tools that have a batch equivalent able to collapse many same-kind
-// queries into a single gated call. Used to point overflow guidance at the
+// queries into one call. The batch-* tools are NOT in the heavy set, so that
+// one call bypasses this gate entirely. Used to point overflow guidance at the
 // right batch-* tool instead of just telling the caller to retry serially.
 const BATCH_EQUIVALENTS = {
     "find-mapping": "batch-mappings",

package/dist/version-service.js

@@ -390,6 +390,13 @@ export class VersionService {
         try {
             const response = await this.fetchFn(url, { signal: timeout.signal });
             if (!response.ok) {
+                // Nothing reads an error body here, and an unread one pins its socket
+                // until GC reaches it. Released best-effort, exactly as `releaseBody`
+                // in repo-downloader.ts: a body that refuses to be cancelled is not a
+                // reason to lose the status the caller actually needs.
+                void response.body?.cancel().catch(() => {
+                    // best-effort release
+                });
                 throw createError({
                     code: ERROR_CODES.REPO_FETCH_FAILED,
                     message: `Request failed for "${url}" with status ${response.status}.`,

package/dist/workspace-context-cache.d.ts

@@ -5,6 +5,22 @@ export type WorkspaceContextEvidence = {
     field: string;
     value?: string;
 };
+/**
+ * A stat-based snapshot of one file the detection that produced a
+ * `WorkspaceContext` actually read, taken at write time. `read()` re-stats
+ * every entry and treats any difference - a changed mtime/size, a file that
+ * appeared, or one that disappeared - as a cache miss, so an edit to a
+ * project's build files invalidates the cached context immediately instead
+ * of waiting out the TTL.
+ */
+export type WorkspaceContextFingerprintEntry = {
+    path: string;
+    mtimeMs: number;
+    size: number;
+} | {
+    path: string;
+    absent: true;
+};
 export type WorkspaceContext = {
     projectPath: string;
     minecraftVersion?: string;
@@ -14,6 +30,7 @@ export type WorkspaceContext = {
     evidence: WorkspaceContextEvidence[];
     dependencyVersions: Map<string, string>;
     partial?: boolean;
+    fingerprint?: WorkspaceContextFingerprintEntry[];
 };
 export interface WorkspaceContextCache {
     read(projectPath: string): WorkspaceContext | undefined;
@@ -27,6 +44,14 @@ export type WorkspaceContextCacheOptions = {
     ttlMs?: number;
     clock?: () => number;
 };
+/**
+ * Stat-snapshot the given file paths (deduplicated, order-independent) for a
+ * `WorkspaceContext.fingerprint`. Exported so the workspace-context populator
+ * (the only place that knows which files a detection actually read) can build
+ * the same shape `read()` compares against, without duplicating the stat
+ * logic or its absent-file handling.
+ */
+export declare function computeWorkspaceContextFingerprint(paths: readonly string[]): WorkspaceContextFingerprintEntry[];
 export declare function createWorkspaceContextCache(opts?: WorkspaceContextCacheOptions): WorkspaceContextCache;
 export declare function getProcessWorkspaceContextCache(): WorkspaceContextCache;
 export declare function resetProcessWorkspaceContextCacheForTesting(): void;

package/dist/workspace-context-cache.js

@@ -1,3 +1,4 @@
+import { statSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import { LruList } from "./lru-list.js";
 const DEFAULT_MAX_ENTRIES = 16;
@@ -5,6 +6,55 @@ const DEFAULT_TTL_MS = 5 * 60_000;
 function normalizeKey(projectPath) {
     return resolvePath(projectPath);
 }
+function currentFingerprintEntry(path) {
+    try {
+        const stats = statSync(path);
+        return { path, mtimeMs: stats.mtimeMs, size: stats.size };
+    }
+    catch {
+        // Missing, unreadable, or a broken symlink - all the same "not there"
+        // state as far as invalidation cares about.
+        return { path, absent: true };
+    }
+}
+/**
+ * Stat-snapshot the given file paths (deduplicated, order-independent) for a
+ * `WorkspaceContext.fingerprint`. Exported so the workspace-context populator
+ * (the only place that knows which files a detection actually read) can build
+ * the same shape `read()` compares against, without duplicating the stat
+ * logic or its absent-file handling.
+ */
+export function computeWorkspaceContextFingerprint(paths) {
+    const unique = Array.from(new Set(paths.map((path) => resolvePath(path))));
+    return unique.map((path) => currentFingerprintEntry(path));
+}
+/**
+ * Whether any file recorded in `ctx.fingerprint` no longer matches its
+ * recorded size/mtime (or its recorded/current absence disagrees). A context
+ * with no fingerprint (nothing was recorded, e.g. a dependency-only partial
+ * entry) never invalidates on this check - only the TTL applies to it.
+ */
+function fingerprintStale(ctx) {
+    if (!ctx.fingerprint || ctx.fingerprint.length === 0) {
+        return false;
+    }
+    for (const recorded of ctx.fingerprint) {
+        const current = currentFingerprintEntry(recorded.path);
+        const recordedAbsent = "absent" in recorded && recorded.absent === true;
+        const currentAbsent = "absent" in current && current.absent === true;
+        if (recordedAbsent !== currentAbsent) {
+            return true;
+        }
+        if (!recordedAbsent && !currentAbsent) {
+            const recordedStat = recorded;
+            const currentStat = current;
+            if (recordedStat.mtimeMs !== currentStat.mtimeMs || recordedStat.size !== currentStat.size) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 export function createWorkspaceContextCache(opts = {}) {
     const maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
     const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
@@ -29,7 +79,7 @@ export function createWorkspaceContextCache(opts = {}) {
             if (!value) {
                 return undefined;
             }
-            if (isExpired(value)) {
+            if (isExpired(value) || fingerprintStale(value)) {
                 lru.remove(key);
                 return undefined;
             }
@@ -46,7 +96,7 @@ export function createWorkspaceContextCache(opts = {}) {
         },
         list() {
             const all = lru.toArray().map((entry) => entry.value);
-            return all.filter((value) => !isExpired(value));
+            return all.filter((value) => !isExpired(value) && !fingerprintStale(value));
         },
         clear() {
             lru.clear();

package/dist/workspace-mapping-service.js

@@ -1,13 +1,121 @@
 import { constants } from "node:fs";
 import { access, readdir, readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { resolve } from "node:path";
 import fastGlob from "fast-glob";
 import { mapWithConcurrencyLimit } from "./concurrency.js";
 import { createError, ERROR_CODES } from "./errors.js";
+import { resolveGradleUserHomePath } from "./gradle-paths.js";
 import { isSafeMavenSegment, isSafeMavenVersionToken } from "./maven-token.js";
 const WORKSPACE_FILE_READ_CONCURRENCY = 4;
-function detectMappingsFromContent(content) {
+function gradleScriptKind(filePath) {
+    return filePath.endsWith(".kts") ? "kotlin" : "groovy";
+}
+/**
+ * Blank out Gradle Groovy/Kotlin line and block comments so a commented-out
+ * alternative (`// mappings loom.officialMojangMappings()`) cannot count as a
+ * mapping declaration — a Yarn project that kept such a note used to look like it
+ * declared two mappings and resolved to none.
+ *
+ * Literals are tracked rather than skipped over, because a `//` inside
+ * `"https://..."` opens no comment and a `/*` inside a string must not swallow the
+ * rest of the script. Newlines inside a removed block comment are preserved so the
+ * remaining declarations keep their line structure.
+ *
+ * The two dialects differ in three places, which is why `scriptKind` is threaded in
+ * from the file name rather than guessed from the text: Kotlin block comments NEST
+ * (Groovy's do not), a Kotlin raw string `"""..."""` has NO escape sequences (so
+ * honoring `\` there would let a literal ending in a backslash hide its own
+ * terminator), and the dollar-slashy literal `$/ ... /$` is Groovy-only.
+ *
+ * When a construct is ambiguous the scanner keeps the text instead of dropping it: a
+ * false mapping conflict is a smaller failure than a declaration that never reaches
+ * the detectors.
+ */
+function stripGradleComments(content, scriptKind) {
+    let output = "";
+    let index = 0;
+    while (index < content.length) {
+        const char = content[index];
+        if (char === "/" && content[index + 1] === "/") {
+            while (index < content.length && content[index] !== "\n") {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && content[index + 1] === "*") {
+            let depth = 1;
+            index += 2;
+            while (index < content.length && depth > 0) {
+                if (scriptKind === "kotlin" && content[index] === "/" && content[index + 1] === "*") {
+                    depth += 1;
+                    index += 2;
+                    continue;
+                }
+                if (content[index] === "*" && content[index + 1] === "/") {
+                    depth -= 1;
+                    index += 2;
+                    continue;
+                }
+                if (content[index] === "\n") {
+                    output += "\n";
+                }
+                index += 1;
+            }
+            continue;
+        }
+        // Groovy dollar-slashy literal: `$/ ... /$`, whose only escapes are `$$` and `$/`.
+        // The plain slashy form `/.../` is deliberately NOT recognized — `/` is also the
+        // division operator, so `a / b / c` is indistinguishable from a literal without
+        // parsing expressions, and mistaking code for a literal would hide real comments.
+        if (scriptKind === "groovy" && char === "$" && content[index + 1] === "/") {
+            output += "$/";
+            index += 2;
+            while (index < content.length) {
+                if (content[index] === "$" && (content[index + 1] === "$" || content[index + 1] === "/")) {
+                    output += content.slice(index, index + 2);
+                    index += 2;
+                    continue;
+                }
+                if (content[index] === "/" && content[index + 1] === "$") {
+                    output += "/$";
+                    index += 2;
+                    break;
+                }
+                output += content[index];
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            // Triple-quoted Groovy/Kotlin blocks close only on the matching triple.
+            const tripled = content.startsWith(char.repeat(3), index);
+            const quote = tripled ? char.repeat(3) : char;
+            const honorsEscapes = !(tripled && scriptKind === "kotlin");
+            output += quote;
+            index += quote.length;
+            while (index < content.length) {
+                if (honorsEscapes && content[index] === "\\") {
+                    output += content.slice(index, index + 2);
+                    index += 2;
+                    continue;
+                }
+                if (content.startsWith(quote, index)) {
+                    output += quote;
+                    index += quote.length;
+                    break;
+                }
+                output += content[index];
+                index += 1;
+            }
+            continue;
+        }
+        output += char;
+        index += 1;
+    }
+    return output;
+}
+function detectMappingsFromContent(rawContent, scriptKind) {
+    const content = stripGradleComments(rawContent, scriptKind);
     const detections = [];
     if (/officialMojangMappings\s*\(/i.test(content)) {
         detections.push({
@@ -149,7 +257,7 @@ async function adoptSubmoduleVersionFromUmbrellaPom(args) {
     if (!umbrellaVersion) {
         return undefined;
     }
-    const umbrellaDir = resolve(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", group, groupSegment, umbrellaVersion);
+    const umbrellaDir = resolve(resolveGradleUserHomePath(), "caches", "modules-2", "files-2.1", group, groupSegment, umbrellaVersion);
     attempts.push(`umbrella-pom:${umbrellaDir}`);
     let hashDirs = [];
     try {
@@ -225,14 +333,8 @@ function compareSemverDescending(left, right) {
  * working; there is still exactly one definition.
  */
 export { isSafeMavenVersionToken };
-function resolveGradleUserHome() {
-    const configured = process.env.GRADLE_USER_HOME?.trim();
-    if (configured) {
-        return configured;
-    }
-    return resolve(homedir(), ".gradle");
-}
-function detectLoadersFromContent(content) {
+function detectLoadersFromContent(rawContent, scriptKind) {
+    const content = stripGradleComments(rawContent, scriptKind);
     const detections = [];
     if (/\bid\s*(?:\(\s*)?["']net\.neoforged\.moddev["']\s*\)?/i.test(content)) {
         detections.push({
@@ -303,7 +405,7 @@ export class WorkspaceMappingService {
             catch {
                 return [];
             }
-            return detectMappingsFromContent(content).map((detection) => ({
+            return detectMappingsFromContent(content, gradleScriptKind(filePath)).map((detection) => ({
                 filePath,
                 mapping: detection.mapping,
                 reason: detection.reason
@@ -439,7 +541,7 @@ export class WorkspaceMappingService {
                 attempts.push(`gradle.properties:${key}`);
             }
         }
-        const modulesDir = resolve(resolveGradleUserHome(), "caches", "modules-2", "files-2.1", group, name);
+        const modulesDir = resolve(resolveGradleUserHomePath(), "caches", "modules-2", "files-2.1", group, name);
         attempts.push(`modules-2:${modulesDir}`);
         let entries = [];
         try {
@@ -520,7 +622,7 @@ export class WorkspaceMappingService {
             catch {
                 return [];
             }
-            return detectLoadersFromContent(content).map((detection) => ({
+            return detectLoadersFromContent(content, gradleScriptKind(filePath)).map((detection) => ({
                 filePath,
                 loader: detection.loader,
                 reason: detection.reason

package/docs/README-ja.md

@@ -264,7 +264,7 @@ stdio トランスポートは、改行区切り形式と `Content-Length` フ
 | `compare-minecraft` | バージョン差分、クラス差分、レジストリ差分、移行向け概要を比較する |
 | `analyze-mod` | Mod メタデータの要約、Mod コードのデコンパイル / 検索、クラスソース確認、リマップのプレビュー / 実行を扱う |
 | `validate-project` | ワークスペース要約と、Mixin / Access Widener / Access Transformer の直接検証を行う |
-| `manage-cache` | キャッシュの一覧、検証、クリーンアップ / 再構築のプレビュー / 実行を行う |
+| `manage-cache` | キャッシュの一覧、検証、クリーンアップのプレビュー / 実行を行う |
 <!-- END GENERATED TOOL TABLE: top-level-workflow-tools -->
 
 ### ソース探索