@adhisang/minecraft-modding-mcp 3.0.0 → 3.1.1

package/dist/config.js

@@ -52,6 +52,17 @@ function expandHome(pathValue) {
     const withoutTilde = pathValue.startsWith("~/") ? pathValue.slice(2) : pathValue.slice(1);
     return resolve(homedir(), withoutTilde);
 }
+function normalizeOptionalPathEnvValue(pathValue) {
+    if (!pathValue) {
+        return undefined;
+    }
+    const trimmed = pathValue.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = trimmed.toLowerCase();
+    return normalized === "undefined" || normalized === "null" ? undefined : trimmed;
+}
 function normalizePath(pathValue, field) {
     const expanded = expandHome(pathValue.trim());
     const normalizedForHost = normalizePathForHost(expanded, undefined, field);
@@ -120,14 +131,11 @@ function parseMappingSourcePriority(envValue) {
     return DEFAULTS.mappingSourcePriority;
 }
 function parseOptionalJarPath(envValue, field) {
-    if (!envValue) {
-        return undefined;
-    }
-    const trimmed = envValue.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    return normalizePath(trimmed, field);
+    const trimmed = normalizeOptionalPathEnvValue(envValue);
+    return trimmed ? normalizePath(trimmed, field) : undefined;
+}
+function parseRequiredPath(envValue, fallback, field) {
+    return normalizePath(normalizeOptionalPathEnvValue(envValue) ?? fallback, field);
 }
 function parseVineflowerPath(envValue) {
     return parseOptionalJarPath(envValue, "MCP_VINEFLOWER_JAR_PATH");
@@ -137,12 +145,12 @@ function buildArtifactsDirectory(cacheDir) {
     return normalizePath(input, "MCP_SQLITE_PATH");
 }
 export function loadConfig() {
-    const cacheDir = normalizePath(process.env.MCP_CACHE_DIR ?? DEFAULTS.cacheDir, "MCP_CACHE_DIR");
-    const localM2Path = normalizePath(process.env.MCP_LOCAL_M2 ?? DEFAULTS.localM2Path, "MCP_LOCAL_M2");
+    const cacheDir = parseRequiredPath(process.env.MCP_CACHE_DIR, DEFAULTS.cacheDir, "MCP_CACHE_DIR");
+    const localM2Path = parseRequiredPath(process.env.MCP_LOCAL_M2, DEFAULTS.localM2Path, "MCP_LOCAL_M2");
     const sourceRepos = parseRepos(process.env.MCP_SOURCE_REPOS);
     return {
         cacheDir,
-        sqlitePath: normalizePath(process.env.MCP_SQLITE_PATH ?? buildArtifactsDirectory(cacheDir), "MCP_SQLITE_PATH"),
+        sqlitePath: parseRequiredPath(process.env.MCP_SQLITE_PATH, buildArtifactsDirectory(cacheDir), "MCP_SQLITE_PATH"),
         sourceRepos,
         localM2Path,
         vineflowerJarPath: parseVineflowerPath(process.env.MCP_VINEFLOWER_JAR_PATH),

package/dist/entry-tools/analyze-mod-service.d.ts

@@ -25,15 +25,15 @@ export declare const analyzeModShape: {
         className: string;
     }>]>;
     query: z.ZodOptional<z.ZodString>;
-    searchType: z.ZodOptional<z.ZodEnum<["class", "method", "field", "content", "all"]>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    includeFiles: z.ZodOptional<z.ZodBoolean>;
+    searchType: z.ZodDefault<z.ZodEnum<["class", "method", "field", "content", "all"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeFiles: z.ZodDefault<z.ZodBoolean>;
     maxFiles: z.ZodOptional<z.ZodNumber>;
     maxLines: z.ZodOptional<z.ZodNumber>;
     maxChars: z.ZodOptional<z.ZodNumber>;
     targetMapping: z.ZodOptional<z.ZodEnum<["yarn", "mojang"]>>;
     outputJar: z.ZodOptional<z.ZodString>;
-    executionMode: z.ZodOptional<z.ZodEnum<["preview", "apply"]>>;
+    executionMode: z.ZodDefault<z.ZodEnum<["preview", "apply"]>>;
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
 };
@@ -62,18 +62,20 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
         className: string;
     }>]>;
     query: z.ZodOptional<z.ZodString>;
-    searchType: z.ZodOptional<z.ZodEnum<["class", "method", "field", "content", "all"]>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    includeFiles: z.ZodOptional<z.ZodBoolean>;
+    searchType: z.ZodDefault<z.ZodEnum<["class", "method", "field", "content", "all"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeFiles: z.ZodDefault<z.ZodBoolean>;
     maxFiles: z.ZodOptional<z.ZodNumber>;
     maxLines: z.ZodOptional<z.ZodNumber>;
     maxChars: z.ZodOptional<z.ZodNumber>;
     targetMapping: z.ZodOptional<z.ZodEnum<["yarn", "mojang"]>>;
     outputJar: z.ZodOptional<z.ZodString>;
-    executionMode: z.ZodOptional<z.ZodEnum<["preview", "apply"]>>;
+    executionMode: z.ZodDefault<z.ZodEnum<["preview", "apply"]>>;
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
 }, "strip", z.ZodTypeAny, {
+    limit: number;
+    searchType: "class" | "method" | "field" | "all" | "content";
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {
         kind: "jar";
@@ -83,18 +85,16 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
         jarPath: string;
         className: string;
     };
-    limit?: number | undefined;
+    includeFiles: boolean;
+    executionMode: "preview" | "apply";
     maxLines?: number | undefined;
     maxChars?: number | undefined;
     targetMapping?: "mojang" | "yarn" | undefined;
     outputJar?: string | undefined;
     query?: string | undefined;
-    searchType?: "class" | "method" | "field" | "all" | "content" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    includeFiles?: boolean | undefined;
     maxFiles?: number | undefined;
-    executionMode?: "preview" | "apply" | undefined;
 }, {
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {
@@ -118,6 +118,8 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
     maxFiles?: number | undefined;
     executionMode?: "preview" | "apply" | undefined;
 }>, {
+    limit: number;
+    searchType: "class" | "method" | "field" | "all" | "content";
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {
         kind: "jar";
@@ -127,18 +129,16 @@ export declare const analyzeModSchema: z.ZodEffects<z.ZodObject<{
         jarPath: string;
         className: string;
     };
-    limit?: number | undefined;
+    includeFiles: boolean;
+    executionMode: "preview" | "apply";
     maxLines?: number | undefined;
     maxChars?: number | undefined;
     targetMapping?: "mojang" | "yarn" | undefined;
     outputJar?: string | undefined;
     query?: string | undefined;
-    searchType?: "class" | "method" | "field" | "all" | "content" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    includeFiles?: boolean | undefined;
     maxFiles?: number | undefined;
-    executionMode?: "preview" | "apply" | undefined;
 }, {
     task: "search" | "remap" | "summary" | "class-source" | "decompile";
     subject: {

package/dist/entry-tools/analyze-mod-service.js

@@ -4,7 +4,7 @@ import { normalizePathForHost } from "../path-converter.js";
 import { createError, ERROR_CODES } from "../errors.js";
 import { z } from "zod";
 import { buildIncludeSchema, detailSchema, executionModeSchema, positiveIntSchema } from "./entry-tool-schema.js";
-import { buildEntryToolResult } from "./response-contract.js";
+import { buildEntryToolResult, createNextAction, createSummarySubject } from "./response-contract.js";
 import { resolveDetail, resolveInclude } from "./request-normalizers.js";
 const nonEmptyString = z.string().trim().min(1);
 const INCLUDE_GROUPS = ["warnings", "files", "source", "samples", "timings"];
@@ -23,15 +23,15 @@ export const analyzeModShape = {
     task: z.enum(["summary", "decompile", "search", "class-source", "remap"]),
     subject: subjectSchema,
     query: nonEmptyString.optional(),
-    searchType: z.enum(["class", "method", "field", "content", "all"]).optional(),
-    limit: positiveIntSchema.optional(),
-    includeFiles: z.boolean().optional(),
+    searchType: z.enum(["class", "method", "field", "content", "all"]).default("all"),
+    limit: positiveIntSchema.default(50),
+    includeFiles: z.boolean().default(true),
     maxFiles: positiveIntSchema.optional(),
     maxLines: positiveIntSchema.optional(),
     maxChars: positiveIntSchema.optional(),
     targetMapping: z.enum(["yarn", "mojang"]).optional(),
     outputJar: nonEmptyString.optional(),
-    executionMode: executionModeSchema.optional(),
+    executionMode: executionModeSchema.default("preview"),
     detail: detailSchema.optional(),
     include: buildIncludeSchema(INCLUDE_GROUPS)
 };
@@ -89,6 +89,11 @@ export class AnalyzeModService {
                         summary: {
                             status: "ok",
                             headline: `Summarized ${analysis.loader} mod metadata.`,
+                            subject: createSummarySubject({
+                                task: "summary",
+                                kind: input.subject.kind,
+                                jarPath: input.subject.jarPath
+                            }),
                             counts: {
                                 classes: analysis.classCount,
                                 dependencies: analysis.dependencies?.length ?? 0
@@ -102,9 +107,10 @@ export class AnalyzeModService {
                 };
             }
             case "decompile": {
+                const includeFiles = input.includeFiles ?? true;
                 const output = await this.deps.decompileModJar({
                     jarPath: input.subject.jarPath,
-                    includeFiles: input.includeFiles,
+                    includeFiles,
                     maxFiles: input.maxFiles
                 });
                 return {
@@ -114,7 +120,14 @@ export class AnalyzeModService {
                         include,
                         summary: {
                             status: "ok",
-                            headline: `Decompiled ${input.subject.jarPath}.`
+                            headline: `Decompiled ${input.subject.jarPath}.`,
+                            subject: createSummarySubject({
+                                task: "decompile",
+                                kind: input.subject.kind,
+                                jarPath: input.subject.jarPath,
+                                includeFiles: includeFiles === true ? undefined : includeFiles,
+                                maxFiles: input.maxFiles
+                            })
                         },
                         blocks: {
                             decompile: output
@@ -124,11 +137,13 @@ export class AnalyzeModService {
                 };
             }
             case "search": {
+                const searchType = input.searchType ?? "all";
+                const limit = input.limit ?? 50;
                 const output = await this.deps.searchModSource({
                     jarPath: input.subject.jarPath,
                     query: input.query,
-                    searchType: input.searchType,
-                    limit: input.limit
+                    searchType,
+                    limit
                 });
                 return {
                     ...buildEntryToolResult({
@@ -137,7 +152,15 @@ export class AnalyzeModService {
                         include,
                         summary: {
                             status: "ok",
-                            headline: `Searched ${input.subject.jarPath} for ${input.query}.`
+                            headline: `Searched ${input.subject.jarPath} for ${input.query}.`,
+                            subject: createSummarySubject({
+                                task: "search",
+                                kind: input.subject.kind,
+                                jarPath: input.subject.jarPath,
+                                query: input.query,
+                                searchType: searchType === "all" ? undefined : searchType,
+                                limit: limit === 50 ? undefined : limit
+                            })
                         },
                         blocks: {
                             hits: output
@@ -166,7 +189,15 @@ export class AnalyzeModService {
                         include,
                         summary: {
                             status: "ok",
-                            headline: `Loaded class source for ${input.subject.className}.`
+                            headline: `Loaded class source for ${input.subject.className}.`,
+                            subject: createSummarySubject({
+                                task: "class-source",
+                                kind: input.subject.kind,
+                                jarPath: input.subject.jarPath,
+                                className: input.subject.className,
+                                maxLines: input.maxLines,
+                                maxChars: input.maxChars
+                            })
                         },
                         blocks: {
                             source: output
@@ -201,7 +232,25 @@ export class AnalyzeModService {
                             include,
                             summary: {
                                 status: "unchanged",
-                                headline: `Previewed remap output for ${normalizedInputJar}.`
+                                headline: `Previewed remap output for ${normalizedInputJar}.`,
+                                subject: createSummarySubject({
+                                    task: "remap",
+                                    kind: input.subject.kind,
+                                    jarPath: normalizedInputJar,
+                                    executionMode: "preview",
+                                    targetMapping: input.targetMapping
+                                }),
+                                nextActions: [
+                                    createNextAction("analyze-mod", {
+                                        task: "remap",
+                                        subject: {
+                                            kind: input.subject.kind,
+                                            jarPath: input.subject.jarPath
+                                        },
+                                        executionMode: "apply",
+                                        targetMapping: input.targetMapping
+                                    })
+                                ]
                             },
                             blocks: {
                                 metadata: {
@@ -232,7 +281,14 @@ export class AnalyzeModService {
                         include,
                         summary: {
                             status: "changed",
-                            headline: `Remapped ${normalizedInputJar} to ${input.targetMapping}.`
+                            headline: `Remapped ${normalizedInputJar} to ${input.targetMapping}.`,
+                            subject: createSummarySubject({
+                                task: "remap",
+                                kind: input.subject.kind,
+                                jarPath: normalizedInputJar,
+                                executionMode: "apply",
+                                targetMapping: input.targetMapping
+                            })
                         },
                         blocks: {
                             operation: {

package/dist/entry-tools/analyze-symbol-service.d.ts

@@ -23,11 +23,11 @@ export declare const analyzeSymbolShape: {
     targetMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
     classNameMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
     projectPath: z.ZodOptional<z.ZodString>;
-    signatureMode: z.ZodOptional<z.ZodEnum<["exact", "name-only"]>>;
-    nameMode: z.ZodOptional<z.ZodEnum<["fqcn", "auto"]>>;
+    signatureMode: z.ZodDefault<z.ZodEnum<["exact", "name-only"]>>;
+    nameMode: z.ZodDefault<z.ZodEnum<["fqcn", "auto"]>>;
     includeKinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["class", "field", "method"]>, "many">>;
     maxRows: z.ZodOptional<z.ZodNumber>;
-    maxCandidates: z.ZodOptional<z.ZodNumber>;
+    maxCandidates: z.ZodDefault<z.ZodNumber>;
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
 };
@@ -54,14 +54,15 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     targetMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
     classNameMapping: z.ZodOptional<z.ZodEnum<["obfuscated", "mojang", "intermediary", "yarn"]>>;
     projectPath: z.ZodOptional<z.ZodString>;
-    signatureMode: z.ZodOptional<z.ZodEnum<["exact", "name-only"]>>;
-    nameMode: z.ZodOptional<z.ZodEnum<["fqcn", "auto"]>>;
+    signatureMode: z.ZodDefault<z.ZodEnum<["exact", "name-only"]>>;
+    nameMode: z.ZodDefault<z.ZodEnum<["fqcn", "auto"]>>;
     includeKinds: z.ZodOptional<z.ZodArray<z.ZodEnum<["class", "field", "method"]>, "many">>;
     maxRows: z.ZodOptional<z.ZodNumber>;
-    maxCandidates: z.ZodOptional<z.ZodNumber>;
+    maxCandidates: z.ZodDefault<z.ZodNumber>;
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
 }, "strip", z.ZodTypeAny, {
+    nameMode: "auto" | "fqcn";
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
         kind: "symbol" | "class" | "method" | "field";
@@ -69,18 +70,17 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
         owner?: string | undefined;
         descriptor?: string | undefined;
     };
+    signatureMode: "exact" | "name-only";
+    maxCandidates: number;
     projectPath?: string | undefined;
     version?: string | undefined;
     sourceMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     targetMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     classNameMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
-    nameMode?: "auto" | "fqcn" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    signatureMode?: "exact" | "name-only" | undefined;
     includeKinds?: ("class" | "method" | "field")[] | undefined;
     maxRows?: number | undefined;
-    maxCandidates?: number | undefined;
 }, {
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
@@ -102,6 +102,7 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
     maxRows?: number | undefined;
     maxCandidates?: number | undefined;
 }>, {
+    nameMode: "auto" | "fqcn";
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
         kind: "symbol" | "class" | "method" | "field";
@@ -109,18 +110,17 @@ export declare const analyzeSymbolSchema: z.ZodEffects<z.ZodObject<{
         owner?: string | undefined;
         descriptor?: string | undefined;
     };
+    signatureMode: "exact" | "name-only";
+    maxCandidates: number;
     projectPath?: string | undefined;
     version?: string | undefined;
     sourceMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     targetMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
     classNameMapping?: "intermediary" | "mojang" | "yarn" | "obfuscated" | undefined;
-    nameMode?: "auto" | "fqcn" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
-    signatureMode?: "exact" | "name-only" | undefined;
     includeKinds?: ("class" | "method" | "field")[] | undefined;
     maxRows?: number | undefined;
-    maxCandidates?: number | undefined;
 }, {
     task: "map" | "workspace" | "exists" | "exact-map" | "lifecycle" | "api-overview";
     subject: {
@@ -180,6 +180,8 @@ type AnalyzeSymbolDeps = {
         symbol: string;
         descriptor?: string;
         mapping?: "obfuscated" | "mojang" | "intermediary" | "yarn";
+        toVersion?: string;
+        maxVersions?: number;
     }) => Promise<TraceSymbolLifecycleOutput>;
     resolveWorkspaceSymbol: (input: {
         projectPath: string;

package/dist/entry-tools/analyze-symbol-service.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { createError, ERROR_CODES } from "../errors.js";
 import { buildIncludeSchema, detailSchema, positiveIntSchema } from "./entry-tool-schema.js";
-import { buildEntryToolResult } from "./response-contract.js";
+import { buildEntryToolResult, createSummarySubject } from "./response-contract.js";
 import { resolveDetail, resolveInclude } from "./request-normalizers.js";
 const nonEmptyString = z.string().trim().min(1);
 const INCLUDE_GROUPS = ["warnings", "candidates", "matrix", "workspace", "timings"];
@@ -19,11 +19,11 @@ export const analyzeSymbolShape = {
     targetMapping: z.enum(["obfuscated", "mojang", "intermediary", "yarn"]).optional(),
     classNameMapping: z.enum(["obfuscated", "mojang", "intermediary", "yarn"]).optional(),
     projectPath: nonEmptyString.optional(),
-    signatureMode: z.enum(["exact", "name-only"]).optional(),
-    nameMode: z.enum(["fqcn", "auto"]).optional(),
+    signatureMode: z.enum(["exact", "name-only"]).default("exact"),
+    nameMode: z.enum(["fqcn", "auto"]).default("fqcn"),
     includeKinds: z.array(z.enum(["class", "field", "method"])).optional(),
     maxRows: positiveIntSchema.optional(),
-    maxCandidates: positiveIntSchema.optional(),
+    maxCandidates: positiveIntSchema.default(200),
     detail: detailSchema.optional(),
     include: buildIncludeSchema(INCLUDE_GROUPS)
 };
@@ -110,6 +110,15 @@ export class AnalyzeSymbolService {
                             headline: output.resolved
                                 ? `The symbol exists in ${output.mappingContext.version}.`
                                 : `The symbol could not be resolved in ${output.mappingContext.version}.`,
+                            subject: createSummarySubject({
+                                task: "exists",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                owner: input.subject.owner,
+                                descriptor: input.subject.descriptor,
+                                version: input.version,
+                                sourceMapping: input.sourceMapping ?? "obfuscated"
+                            }),
                             counts: {
                                 candidates: output.candidateCount
                             }
@@ -145,6 +154,16 @@ export class AnalyzeSymbolService {
                             headline: output.resolved
                                 ? `Mapped the symbol into ${output.mappingContext.targetMapping}.`
                                 : `Found ${output.candidateCount} candidate mappings.`,
+                            subject: createSummarySubject({
+                                task: "map",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                owner: input.subject.owner,
+                                descriptor: input.subject.descriptor,
+                                version: input.version,
+                                sourceMapping: input.sourceMapping ?? "obfuscated",
+                                targetMapping: input.targetMapping ?? "mojang"
+                            }),
                             counts: {
                                 candidates: output.candidateCount
                             }
@@ -184,6 +203,16 @@ export class AnalyzeSymbolService {
                             headline: output.resolved
                                 ? "Resolved the exact method mapping."
                                 : "Could not resolve the exact method mapping.",
+                            subject: createSummarySubject({
+                                task: "exact-map",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                owner: input.subject.owner,
+                                descriptor: input.subject.descriptor,
+                                version: input.version,
+                                sourceMapping: input.sourceMapping ?? "obfuscated",
+                                targetMapping: input.targetMapping ?? "mojang"
+                            }),
                             counts: {
                                 candidates: output.candidateCount
                             }
@@ -202,7 +231,9 @@ export class AnalyzeSymbolService {
                         ? `${input.subject.owner}.${input.subject.name}`
                         : input.subject.name,
                     descriptor: input.subject.descriptor,
-                    mapping: input.sourceMapping
+                    mapping: input.sourceMapping,
+                    toVersion: input.version,
+                    maxVersions: 5
                 });
                 return {
                     ...buildEntryToolResult({
@@ -214,6 +245,15 @@ export class AnalyzeSymbolService {
                             headline: output.presence.firstSeen
                                 ? `Tracked the symbol from ${output.range.fromVersion} to ${output.range.toVersion}.`
                                 : "The symbol was not found in the scanned version range.",
+                            subject: createSummarySubject({
+                                task: "lifecycle",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                owner: input.subject.owner,
+                                descriptor: input.subject.descriptor,
+                                version: input.version,
+                                sourceMapping: input.sourceMapping ?? "obfuscated"
+                            }),
                             counts: {
                                 scannedVersions: output.range.scannedCount
                             }
@@ -247,6 +287,16 @@ export class AnalyzeSymbolService {
                             headline: output.workspaceDetection.resolved
                                 ? `Resolved compile-visible symbol using ${output.workspaceDetection.mappingApplied} workspace mappings.`
                                 : "Workspace compile mapping could not be detected confidently.",
+                            subject: createSummarySubject({
+                                task: "workspace",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                owner: input.subject.owner,
+                                descriptor: input.subject.descriptor,
+                                projectPath: input.projectPath,
+                                version: input.version ?? "unknown",
+                                sourceMapping: input.sourceMapping ?? "obfuscated"
+                            }),
                             counts: {
                                 candidates: output.candidateCount
                             }
@@ -261,10 +311,11 @@ export class AnalyzeSymbolService {
                 };
             }
             case "api-overview": {
+                const classNameMapping = input.classNameMapping ?? input.sourceMapping ?? "obfuscated";
                 const output = await this.deps.getClassApiMatrix({
                     version: input.version,
                     className: input.subject.name,
-                    classNameMapping: input.classNameMapping ?? "obfuscated",
+                    classNameMapping,
                     includeKinds: input.includeKinds,
                     maxRows: input.maxRows
                 });
@@ -276,6 +327,13 @@ export class AnalyzeSymbolService {
                         summary: {
                             status: "ok",
                             headline: `Built an API overview for ${output.className}.`,
+                            subject: createSummarySubject({
+                                task: "api-overview",
+                                kind: input.subject.kind,
+                                name: input.subject.name,
+                                version: input.version,
+                                classNameMapping
+                            }),
                             counts: {
                                 rows: output.rowCount,
                                 ambiguousRows: output.ambiguousRowCount ?? 0

package/dist/entry-tools/compare-minecraft-service.d.ts

@@ -59,9 +59,9 @@ export declare const compareMinecraftShape: {
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
     limit: z.ZodOptional<z.ZodNumber>;
-    maxClassResults: z.ZodOptional<z.ZodNumber>;
+    maxClassResults: z.ZodDefault<z.ZodNumber>;
     maxEntriesPerRegistry: z.ZodOptional<z.ZodNumber>;
-    includeFullDiff: z.ZodOptional<z.ZodBoolean>;
+    includeFullDiff: z.ZodDefault<z.ZodBoolean>;
 };
 export declare const compareMinecraftSchema: z.ZodObject<{
     task: z.ZodOptional<z.ZodEnum<["auto", "versions", "class-diff", "registry-diff", "migration-overview"]>>;
@@ -120,10 +120,11 @@ export declare const compareMinecraftSchema: z.ZodObject<{
     detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
     include: z.ZodOptional<z.ZodArray<z.ZodEnum<[string, ...string[]]>, "many">>;
     limit: z.ZodOptional<z.ZodNumber>;
-    maxClassResults: z.ZodOptional<z.ZodNumber>;
+    maxClassResults: z.ZodDefault<z.ZodNumber>;
     maxEntriesPerRegistry: z.ZodOptional<z.ZodNumber>;
-    includeFullDiff: z.ZodOptional<z.ZodBoolean>;
+    includeFullDiff: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    maxClassResults: number;
     subject: {
         kind: "version-pair";
         fromVersion: string;
@@ -142,13 +143,12 @@ export declare const compareMinecraftSchema: z.ZodObject<{
         toVersion: string;
         registry?: string | undefined;
     };
+    includeFullDiff: boolean;
     limit?: number | undefined;
-    maxClassResults?: number | undefined;
     task?: "auto" | "versions" | "class-diff" | "registry-diff" | "migration-overview" | undefined;
     detail?: "full" | "summary" | "standard" | undefined;
     include?: string[] | undefined;
     maxEntriesPerRegistry?: number | undefined;
-    includeFullDiff?: boolean | undefined;
 }, {
     subject: {
         kind: "version-pair";