gitnexus 1.6.3-rc.21 → 1.6.3-rc.23

package/dist/mcp/local/local-backend.js

@@ -16,6 +16,7 @@ export { isWriteQuery };
 import { parseDiffHunks } from '../../storage/git.js';
 import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-manager.js';
 import { GroupService } from '../../core/group/service.js';
+import { resolveAtGroupMemberRepoPath } from '../../core/group/resolve-at-member.js';
 import { collectBestChunks } from '../../core/embeddings/types.js';
 import { EMBEDDING_TABLE_NAME, EMBEDDING_INDEX_NAME } from '../../core/lbug/schema.js';
 import { PhaseTimer } from '../../core/search/phase-timer.js';
@@ -171,6 +172,7 @@ export class LocalBackend {
                 impact: (r, p) => this.impact(r, p),
                 query: (r, p) => this.query(r, p),
                 impactByUid: (id, uid, d, o) => this.impactByUid(id, uid, d, o),
+                context: (r, p) => this.context(r, p),
             };
             this.groupToolSvc = new GroupService(port);
         }
@@ -423,6 +425,12 @@ export class LocalBackend {
         if (method.startsWith('group_')) {
             return this.handleGroupTool(method, params || {});
         }
+        const p = params && typeof params === 'object' ? params : {};
+        if ((method === 'impact' || method === 'query' || method === 'context') &&
+            typeof p.repo === 'string' &&
+            p.repo.startsWith('@')) {
+            return this.callToolAtGroupRepo(method, p);
+        }
         // Resolve repo from optional param (re-reads registry on miss)
         const repo = await this.resolveRepo(params?.repo);
         switch (method) {
@@ -2301,32 +2309,150 @@ export class LocalBackend {
                 return this.groupList(params);
             case 'group_sync':
                 return this.groupSync(params);
-            case 'group_contracts':
-                return this.groupContracts(params);
-            case 'group_query':
-                return this.groupQuery(params);
-            case 'group_status':
-                return this.groupStatus(params);
             default:
-                throw new Error(`Unknown group tool: ${method}`);
+                throw new Error(`Unknown group tool: ${method}. Removed tools: use repo "@<groupName>" on impact, query, or context (optional "/<memberPath>"), or MCP resources.`);
         }
     }
+    /**
+     * Dispatch impact/query/context when `repo` is `@groupName` or `@groupName/memberPath`
+     * (group mode — not the global indexed-repo `repo` parameter).
+     */
+    async callToolAtGroupRepo(method, params) {
+        await this.refreshRepos();
+        if (params.service !== undefined &&
+            params.service !== null &&
+            String(params.service).trim() === '') {
+            return { error: 'service must not be an empty string' };
+        }
+        const raw = String(params.repo).slice(1);
+        const slash = raw.indexOf('/');
+        const groupName = (slash === -1 ? raw : raw.slice(0, slash)).trim();
+        const memberRest = slash === -1 ? undefined : raw.slice(slash + 1).trim() || undefined;
+        const resolved = await resolveAtGroupMemberRepoPath(groupName, memberRest);
+        if (resolved.ok === false)
+            return { error: resolved.error };
+        const svc = this.getGroupService();
+        if (method === 'impact') {
+            const impactArgs = {
+                name: groupName,
+                repo: resolved.repoPath,
+                target: params.target,
+                direction: params.direction,
+            };
+            if (params.maxDepth !== undefined)
+                impactArgs.maxDepth = params.maxDepth;
+            if (params.crossDepth !== undefined)
+                impactArgs.crossDepth = params.crossDepth;
+            if (params.relationTypes !== undefined)
+                impactArgs.relationTypes = params.relationTypes;
+            if (params.includeTests !== undefined)
+                impactArgs.includeTests = params.includeTests;
+            if (params.minConfidence !== undefined)
+                impactArgs.minConfidence = params.minConfidence;
+            if (params.service !== undefined && params.service !== null)
+                impactArgs.service = params.service;
+            if (typeof params.subgroup === 'string')
+                impactArgs.subgroup = params.subgroup;
+            if (params.timeoutMs !== undefined)
+                impactArgs.timeoutMs = params.timeoutMs;
+            if (params.timeout !== undefined)
+                impactArgs.timeout = params.timeout;
+            return svc.groupImpact(impactArgs);
+        }
+        if (method === 'query') {
+            const queryArgs = {
+                name: groupName,
+                query: params.query,
+            };
+            if (typeof params.task_context === 'string')
+                queryArgs.task_context = params.task_context;
+            if (typeof params.goal === 'string')
+                queryArgs.goal = params.goal;
+            if (typeof params.limit === 'number')
+                queryArgs.limit = params.limit;
+            if (typeof params.max_symbols === 'number')
+                queryArgs.max_symbols = params.max_symbols;
+            if (params.include_content !== undefined)
+                queryArgs.include_content = params.include_content;
+            if (params.service !== undefined && params.service !== null)
+                queryArgs.service = params.service;
+            if (memberRest !== undefined) {
+                queryArgs.subgroup = memberRest;
+                queryArgs.subgroupExact = true;
+            }
+            return svc.groupQuery(queryArgs);
+        }
+        if (method === 'context') {
+            const targetSym = typeof params.target === 'string' && params.target.trim() !== ''
+                ? params.target.trim()
+                : typeof params.name === 'string' && params.name.trim() !== ''
+                    ? params.name.trim()
+                    : undefined;
+            const contextArgs = {
+                name: groupName,
+                target: targetSym,
+            };
+            if (typeof params.uid === 'string')
+                contextArgs.uid = params.uid;
+            if (typeof params.file_path === 'string')
+                contextArgs.file_path = params.file_path;
+            if (params.include_content !== undefined)
+                contextArgs.include_content = params.include_content;
+            if (params.service !== undefined && params.service !== null)
+                contextArgs.service = params.service;
+            if (memberRest !== undefined) {
+                contextArgs.subgroup = memberRest;
+                contextArgs.subgroupExact = true;
+            }
+            return svc.groupContext(contextArgs);
+        }
+        throw new Error(`Internal: unsupported group-repo tool ${method}`);
+    }
     async groupList(params) {
         return this.getGroupService().groupList(params);
     }
     async groupSync(params) {
         return this.getGroupService().groupSync(params);
     }
-    async groupContracts(params) {
-        return this.getGroupService().groupContracts(params);
+    /**
+     * MCP resource body for `gitnexus://group/{name}/contracts` (Issue #794).
+     */
+    async readGroupContractsResource(groupName, filter) {
+        try {
+            const params = { name: groupName };
+            if (filter.type !== undefined)
+                params.type = filter.type;
+            if (filter.repo !== undefined)
+                params.repo = filter.repo;
+            if (filter.unmatchedOnly === true)
+                params.unmatchedOnly = true;
+            const raw = await this.getGroupService().groupContracts(params);
+            return LocalBackend.formatGroupResourcePayload(raw);
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : String(e)}`;
+        }
     }
-    async groupQuery(params) {
-        await this.refreshRepos();
-        return this.getGroupService().groupQuery(params);
+    /**
+     * MCP resource body for `gitnexus://group/{name}/status` (Issue #794).
+     */
+    async readGroupStatusResource(groupName) {
+        try {
+            const raw = await this.getGroupService().groupStatus({ name: groupName });
+            return LocalBackend.formatGroupResourcePayload(raw);
+        }
+        catch (e) {
+            return `error: ${e instanceof Error ? e.message : String(e)}`;
+        }
     }
-    async groupStatus(params) {
-        await this.refreshRepos();
-        return this.getGroupService().groupStatus(params);
+    static formatGroupResourcePayload(raw) {
+        if (raw && typeof raw === 'object' && 'error' in raw) {
+            const err = raw.error;
+            if (typeof err === 'string' && err.length > 0) {
+                return `error: ${err}`;
+            }
+        }
+        return JSON.stringify(raw, null, 2);
     }
     /**
      * Fetch Route nodes with their consumers in a single query.

package/dist/mcp/resources.d.ts

@@ -25,6 +25,37 @@ export declare function getResourceDefinitions(): ResourceDefinition[];
  * Dynamic resource templates
  */
 export declare function getResourceTemplates(): ResourceTemplate[];
+/** Query parameters for `gitnexus://group/{name}/contracts` */
+export type GroupContractsResourceFilter = {
+    type?: string;
+    repo?: string;
+    unmatchedOnly?: boolean;
+};
+/** Normalized parse result for GitNexus MCP resource URIs */
+export type ParsedGitnexusResource = {
+    kind: 'repos';
+} | {
+    kind: 'setup';
+} | {
+    kind: 'repo';
+    repoName: string;
+    resourceType: string;
+    param?: string;
+} | {
+    kind: 'group';
+    groupName: string;
+    resourceType: 'contracts';
+    contractsFilter: GroupContractsResourceFilter;
+} | {
+    kind: 'group';
+    groupName: string;
+    resourceType: 'status';
+};
+/**
+ * Parse a GitNexus resource URI (repos, setup, per-repo, or per-group templates).
+ * Used by `readResource` and tests (round-trip / dispatch coverage).
+ */
+export declare function parseResourceUri(uri: string): ParsedGitnexusResource;
 /**
  * Read a resource and return its content
  */

package/dist/mcp/resources.js

@@ -65,36 +65,113 @@ export function getResourceTemplates() {
             description: 'Step-by-step execution trace',
             mimeType: 'text/yaml',
         },
+        {
+            uriTemplate: 'gitnexus://group/{name}/contracts',
+            name: 'Group Contract Registry',
+            description: 'Cross-repo contract registry for a repository group. Optional query: type, repo, unmatchedOnly (true|false).',
+            mimeType: 'text/yaml',
+        },
+        {
+            uriTemplate: 'gitnexus://group/{name}/status',
+            name: 'Group Index Status',
+            description: 'Per-repo index and contract-registry staleness for a repository group',
+            mimeType: 'text/yaml',
+        },
     ];
 }
+function parseUnmatchedOnlyParam(raw) {
+    if (raw === null)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === 'true' || v === '1')
+        return true;
+    if (v === 'false' || v === '0')
+        return false;
+    return undefined;
+}
 /**
- * Parse a resource URI to extract the repo name and resource type.
+ * Parse a GitNexus resource URI (repos, setup, per-repo, or per-group templates).
+ * Used by `readResource` and tests (round-trip / dispatch coverage).
  */
-function parseUri(uri) {
+export function parseResourceUri(uri) {
     if (uri === 'gitnexus://repos')
-        return { resourceType: 'repos' };
+        return { kind: 'repos' };
     if (uri === 'gitnexus://setup')
-        return { resourceType: 'setup' };
-    // Repo-scoped: gitnexus://repo/{name}/context
-    const repoMatch = uri.match(/^gitnexus:\/\/repo\/([^/]+)\/(.+)$/);
-    if (repoMatch) {
-        const repoName = decodeURIComponent(repoMatch[1]);
-        const rest = repoMatch[2];
+        return { kind: 'setup' };
+    let u;
+    try {
+        u = new URL(uri);
+    }
+    catch {
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+    if (u.protocol !== 'gitnexus:') {
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+    if (u.hostname === 'group') {
+        const segments = u.pathname
+            .replace(/^\/+|\/+$/g, '')
+            .split('/')
+            .filter(Boolean);
+        if (segments.length < 2) {
+            throw new Error(`Invalid group resource URI (expected gitnexus://group/{name}/contracts or .../status): ${uri}`);
+        }
+        const tail = segments[segments.length - 1];
+        if (tail !== 'contracts' && tail !== 'status') {
+            throw new Error(`Unknown group resource path in URI: ${uri}`);
+        }
+        const groupName = segments
+            .slice(0, -1)
+            .map((s) => decodeURIComponent(s))
+            .join('/');
+        if (!groupName) {
+            throw new Error(`Invalid group resource URI (empty group name): ${uri}`);
+        }
+        if (tail === 'status') {
+            return { kind: 'group', groupName, resourceType: 'status' };
+        }
+        const contractsFilter = {};
+        const type = u.searchParams.get('type');
+        if (type && type.trim())
+            contractsFilter.type = type.trim();
+        const repo = u.searchParams.get('repo');
+        if (repo && repo.trim())
+            contractsFilter.repo = repo.trim();
+        if (u.searchParams.has('unmatchedOnly')) {
+            const coerced = parseUnmatchedOnlyParam(u.searchParams.get('unmatchedOnly'));
+            if (coerced !== undefined)
+                contractsFilter.unmatchedOnly = coerced;
+        }
+        return { kind: 'group', groupName, resourceType: 'contracts', contractsFilter };
+    }
+    if (u.hostname === 'repo') {
+        const segments = u.pathname
+            .replace(/^\/+|\/+$/g, '')
+            .split('/')
+            .filter(Boolean);
+        if (segments.length < 2) {
+            throw new Error(`Unknown resource URI: ${uri}`);
+        }
+        const repoName = decodeURIComponent(segments[0]);
+        const restEncoded = segments.slice(1);
+        const rest = restEncoded.map((s) => decodeURIComponent(s)).join('/');
         if (rest.startsWith('cluster/')) {
             return {
+                kind: 'repo',
                 repoName,
                 resourceType: 'cluster',
-                param: decodeURIComponent(rest.replace('cluster/', '')),
+                param: rest.replace(/^cluster\//, ''),
             };
         }
         if (rest.startsWith('process/')) {
             return {
+                kind: 'repo',
                 repoName,
                 resourceType: 'process',
-                param: decodeURIComponent(rest.replace('process/', '')),
+                param: rest.replace(/^process\//, ''),
             };
         }
-        return { repoName, resourceType: rest };
+        return { kind: 'repo', repoName, resourceType: rest };
     }
     throw new Error(`Unknown resource URI: ${uri}`);
 }
@@ -102,15 +179,19 @@ function parseUri(uri) {
  * Read a resource and return its content
  */
 export async function readResource(uri, backend) {
-    const parsed = parseUri(uri);
-    // Global repos list — no repo context needed
-    if (parsed.resourceType === 'repos') {
+    const parsed = parseResourceUri(uri);
+    if (parsed.kind === 'repos') {
         return getReposResource(backend);
     }
-    // Setup resource — returns AGENTS.md content for all repos
-    if (parsed.resourceType === 'setup') {
+    if (parsed.kind === 'setup') {
         return getSetupResource(backend);
     }
+    if (parsed.kind === 'group') {
+        if (parsed.resourceType === 'contracts') {
+            return backend.readGroupContractsResource(parsed.groupName, parsed.contractsFilter);
+        }
+        return backend.readGroupStatusResource(parsed.groupName);
+    }
     const repoName = parsed.repoName;
     switch (parsed.resourceType) {
         case 'context':
@@ -202,6 +283,8 @@ async function getContextResource(backend, repoName) {
     lines.push(`  - gitnexus://repo/${context.projectName}/processes: All execution flows`);
     lines.push(`  - gitnexus://repo/${context.projectName}/cluster/{name}: Module details`);
     lines.push(`  - gitnexus://repo/${context.projectName}/process/{name}: Process trace`);
+    lines.push('  - gitnexus://group/{name}/contracts: Group contract registry (optional ?type=&repo=&unmatchedOnly=)');
+    lines.push('  - gitnexus://group/{name}/status: Group index / contract staleness');
     return lines.join('\n');
 }
 /**

package/dist/mcp/tools.d.ts

@@ -12,11 +12,14 @@ export interface ToolDefinition {
         properties: Record<string, {
             type: string;
             description?: string;
-            default?: any;
+            default?: unknown;
             items?: {
                 type: string;
             };
             enum?: string[];
+            minimum?: number;
+            maximum?: number;
+            minLength?: number;
         }>;
         required: string[];
     };

package/dist/mcp/tools.js

@@ -35,7 +35,11 @@ Returns results grouped by process (execution flow):
 - process_symbols: all symbols in those flows with file locations and module (functional area)
 - definitions: standalone types/interfaces not in any process
 
-Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.`,
+Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.
+
+GROUP MODE: set "repo" to "@<groupName>" to search all member repos in that group (merged via RRF), or "@<groupName>/<groupRepoPath>" to run against a single member (same path keys as in group.yaml). If you use "@<groupName>" only, the member repo defaults to the lexicographically first key in group.yaml "repos". Prefer resources for contracts/status (see migration from legacy group_* tools).
+
+SERVICE: optional monorepo path prefix (POSIX-style, case-sensitive segments). When "repo" starts with "@", only processes whose symbols fall under that prefix are included. For a normal indexed repo name (no leading @), this field is currently ignored by the server.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -48,11 +52,19 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                     type: 'string',
                     description: 'What you want to find (e.g., "existing auth validation logic"). Helps ranking.',
                 },
-                limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
+                limit: {
+                    type: 'number',
+                    description: 'Max processes to return (default: 5)',
+                    default: 5,
+                    minimum: 1,
+                    maximum: 100,
+                },
                 max_symbols: {
                     type: 'number',
                     description: 'Max symbols per process (default: 10)',
                     default: 10,
+                    minimum: 1,
+                    maximum: 200,
                 },
                 include_content: {
                     type: 'boolean',
@@ -61,7 +73,12 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>" (member path keys from group.yaml). Omit when only one indexed repo exists.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path, "/" separators). In group mode (@repo), prefix-matches symbol file paths; ignored for a normal repo name. Empty string is rejected server-side.',
                 },
             },
             required: ['query'],
@@ -135,7 +152,11 @@ AFTER THIS: Use impact() if planning changes, or READ gitnexus://repo/{name}/pro
 
 Handles disambiguation: if multiple symbols share the same name, returns ranked candidates (each with a relevance score) for you to pick from. Use uid for zero-ambiguity lookup, or narrow the search with file_path and/or kind hints.
 
-NOTE: ACCESSES edges (field read/write tracking) are included in context results with reason 'read' or 'write'. CALLS edges resolve through field access chains and method-call chains (e.g., user.address.getCity().save() produces CALLS edges at each step).`,
+NOTE: ACCESSES edges (field read/write tracking) are included in context results with reason 'read' or 'write'. CALLS edges resolve through field access chains and method-call chains (e.g., user.address.getCity().save() produces CALLS edges at each step).
+
+GROUP MODE: set "repo" to "@<groupName>" to run context in each member repo (aggregated list), or "@<groupName>/<groupRepoPath>" for one member. If you use "@<groupName>" only, the member defaults to the lexicographically first key in group.yaml "repos".
+
+SERVICE: optional monorepo path prefix (case-sensitive path segments). When "repo" starts with "@", prefix-matches resolved symbol file paths; when a hit is outside the prefix, that member returns an empty payload for the symbol. Ignored for a normal indexed repo name.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -156,7 +177,12 @@ NOTE: ACCESSES edges (field read/write tracking) are included in context results
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path). Applies in group mode (@repo) only; ignored for a normal repo name. Empty string is rejected server-side.',
                 },
             },
             required: [],
@@ -251,7 +277,11 @@ TIP: Default traversal uses CALLS/IMPORTS/EXTENDS/IMPLEMENTS. For class members,
 Handles disambiguation: when multiple symbols share the target name, returns ranked candidates (each with a relevance score) instead of silently picking one. Use target_uid for zero-ambiguity lookup, or narrow with file_path and/or kind hints.
 
 EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, METHOD_OVERRIDES, METHOD_IMPLEMENTS, ACCESSES
-Confidence: 1.0 = certain, <0.8 = fuzzy match`,
+Confidence: 1.0 = certain, <0.8 = fuzzy match
+
+GROUP MODE: set "repo" to "@<groupName>" for cross-repo impact anchored at the default member (lexicographically first key in group.yaml "repos"), or "@<groupName>/<groupRepoPath>" to choose the member (same path keys as in group.yaml). Phase-1 walk runs in that member; cross-boundary fan-out uses the group bridge.
+
+SERVICE: optional monorepo path prefix (case-sensitive path segments). When "repo" starts with "@", scopes the local impact walk and cross-repo symbol paths to files under that prefix; ignored for a normal indexed repo name.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -274,8 +304,17 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                 },
                 maxDepth: {
                     type: 'number',
-                    description: 'Max relationship depth (default: 3)',
+                    description: 'Max relationship depth (default: 3, server clamps to 1–32)',
                     default: 3,
+                    minimum: 1,
+                    maximum: 32,
+                },
+                crossDepth: {
+                    type: 'number',
+                    description: 'Cross-repository hop depth via contract bridge (default: 1; values above server maximum are clamped)',
+                    default: 1,
+                    minimum: 1,
+                    maximum: 32,
                 },
                 relationTypes: {
                     type: 'array',
@@ -283,10 +322,37 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
                     description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, METHOD_OVERRIDES, METHOD_IMPLEMENTS, ACCESSES (default: usage-based, ACCESSES excluded by default)',
                 },
                 includeTests: { type: 'boolean', description: 'Include test files (default: false)' },
-                minConfidence: { type: 'number', description: 'Minimum confidence 0-1 (default: 0.7)' },
+                minConfidence: {
+                    type: 'number',
+                    description: 'Minimum edge confidence 0–1 (default: 0 when omitted; server clamps to 0–1)',
+                    default: 0,
+                    minimum: 0,
+                    maximum: 1,
+                },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                },
+                service: {
+                    type: 'string',
+                    minLength: 1,
+                    description: 'Optional monorepo service root (relative path). Applies when "repo" is group mode (@…); ignored for a normal repo name. Empty string is rejected server-side.',
+                },
+                subgroup: {
+                    type: 'string',
+                    description: 'Optional group subgroup prefix (member repo paths) limiting which repos participate in cross fan-out.',
+                },
+                timeoutMs: {
+                    type: 'number',
+                    description: 'Wall-clock budget in milliseconds for the Phase-1 local impact leg (default 30000)',
+                    minimum: 1,
+                    maximum: 3600000,
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Alias of timeoutMs (milliseconds) when timeoutMs is omitted',
+                    minimum: 1,
+                    maximum: 3600000,
                 },
             },
             required: ['target', 'direction'],
@@ -404,49 +470,4 @@ WHEN TO USE: After changing group.yaml or re-indexing member repos.`,
             required: ['name'],
         },
     },
-    {
-        name: 'group_contracts',
-        description: `Inspect contracts and cross-links from the group's contracts.json.
-
-WHEN TO USE: Debug cross-repo links after group_sync.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-                type: { type: 'string', description: 'Filter by contract type (http, topic, …)' },
-                repo: { type: 'string', description: 'Filter by group repo path (e.g. app/backend)' },
-                unmatchedOnly: { type: 'boolean', description: 'Only contracts with no cross-link' },
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'group_query',
-        description: `Run the query tool across all repos in a group and merge process results via reciprocal rank fusion.
-
-WHEN TO USE: Semantic / hybrid search across a whole product group.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-                query: { type: 'string', description: 'Search query' },
-                subgroup: { type: 'string', description: 'Limit to repo paths under this prefix' },
-                limit: { type: 'number', description: 'Max merged results (default 5)' },
-            },
-            required: ['name', 'query'],
-        },
-    },
-    {
-        name: 'group_status',
-        description: `Report index staleness (commit vs HEAD) and Contract Registry staleness (indexedAt) for each repo in a group.
-
-WHEN TO USE: Before group_sync or when agents should refresh indexes.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Group name' },
-            },
-            required: ['name'],
-        },
-    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.3-rc.21",
+  "version": "1.6.3-rc.23",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",