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

package/dist/core/group/service.js

@@ -2,15 +2,125 @@
  * Group orchestration shared by MCP (LocalBackend) and CLI.
  * DB access is injected via GroupToolPort so this module stays free of LocalBackend private API.
  */
+import fsp from 'node:fs/promises';
+import path from 'node:path';
 import { checkStaleness } from '../git-staleness.js';
 import { loadGroupConfig } from './config-parser.js';
+import { fileMatchesServicePrefix, normalizeServicePrefix, repoInSubgroup, } from './group-path-utils.js';
 import { getDefaultGitnexusDir, getGroupDir, listGroups, readContractRegistry } from './storage.js';
 import { syncGroup } from './sync.js';
-function repoInSubgroup(repoPath, subgroup) {
-    if (!subgroup?.trim())
-        return true;
-    const s = subgroup.replace(/\/+$/, '');
-    return repoPath === s || repoPath.startsWith(`${s}/`);
+function isStoredContract(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const o = raw;
+    return (typeof o.contractId === 'string' &&
+        typeof o.type === 'string' &&
+        typeof o.repo === 'string' &&
+        typeof o.role === 'string' &&
+        (o.role === 'provider' || o.role === 'consumer') &&
+        typeof o.symbolUid === 'string' &&
+        typeof o.symbolName === 'string' &&
+        typeof o.confidence === 'number' &&
+        o.meta !== undefined &&
+        typeof o.meta === 'object' &&
+        o.meta !== null &&
+        o.symbolRef !== undefined &&
+        typeof o.symbolRef === 'object' &&
+        o.symbolRef !== null &&
+        typeof o.symbolRef.filePath === 'string' &&
+        typeof o.symbolRef.name === 'string');
+}
+function filterQueryByServicePrefix(queryResult, servicePrefix) {
+    const symbols = (queryResult.process_symbols || []).filter((s) => fileMatchesServicePrefix(typeof s.filePath === 'string' ? s.filePath : undefined, servicePrefix));
+    const allowed = new Set(symbols.map((s) => String(s.process_id ?? '')).filter(Boolean));
+    const processes = (queryResult.processes || []).filter((p) => allowed.has(String(p.id)));
+    return { processes, process_symbols: symbols };
+}
+function isCrossLink(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    const o = raw;
+    const from = o.from;
+    const to = o.to;
+    if (!from || !to)
+        return false;
+    if (typeof from.repo !== 'string' || typeof to.repo !== 'string')
+        return false;
+    return typeof o.contractId === 'string' && typeof o.type === 'string';
+}
+async function loadContractRegistryResilient(groupDir) {
+    const filePath = path.join(groupDir, 'contracts.json');
+    let raw;
+    try {
+        raw = await fsp.readFile(filePath, 'utf-8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return { ok: false, error: `No contracts.json for this group. Run group_sync first.` };
+        }
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+    let root;
+    try {
+        root = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, error: 'contracts.json is not valid JSON' };
+    }
+    if (!root || typeof root !== 'object' || Array.isArray(root)) {
+        return { ok: false, error: 'contracts.json has an invalid root object' };
+    }
+    const base = root;
+    const contractsRaw = base.contracts;
+    const crossRaw = base.crossLinks;
+    let skippedCorrupt = 0;
+    const contracts = [];
+    if (Array.isArray(contractsRaw)) {
+        for (const row of contractsRaw) {
+            try {
+                if (isStoredContract(row)) {
+                    contracts.push(row);
+                }
+                else {
+                    skippedCorrupt++;
+                    console.warn('[group] skipping corrupt contract row in contracts.json');
+                }
+            }
+            catch {
+                skippedCorrupt++;
+                console.warn('[group] skipping corrupt contract row in contracts.json');
+            }
+        }
+    }
+    const crossLinks = [];
+    if (Array.isArray(crossRaw)) {
+        for (const row of crossRaw) {
+            try {
+                if (isCrossLink(row)) {
+                    crossLinks.push(row);
+                }
+                else {
+                    skippedCorrupt++;
+                    console.warn('[group] skipping corrupt crossLinks row in contracts.json');
+                }
+            }
+            catch {
+                skippedCorrupt++;
+                console.warn('[group] skipping corrupt crossLinks row in contracts.json');
+            }
+        }
+    }
+    const registry = {
+        version: typeof base.version === 'number' ? base.version : 0,
+        generatedAt: typeof base.generatedAt === 'string' ? base.generatedAt : '',
+        repoSnapshots: base.repoSnapshots && typeof base.repoSnapshots === 'object' && base.repoSnapshots !== null
+            ? base.repoSnapshots
+            : {},
+        missingRepos: Array.isArray(base.missingRepos) ? base.missingRepos : [],
+        contracts,
+        crossLinks,
+    };
+    return { ok: true, registry, skippedCorrupt };
 }
 export class GroupService {
     port;
@@ -57,10 +167,14 @@ export class GroupService {
         if (!name)
             return { error: 'name is required' };
         const groupDir = getGroupDir(getDefaultGitnexusDir(), name);
-        const registry = await readContractRegistry(groupDir);
-        if (!registry) {
-            return { error: `No contracts.json for group "${name}". Run group_sync first.` };
+        const loaded = await loadContractRegistryResilient(groupDir);
+        if (loaded.ok === false) {
+            if (loaded.error.includes('No contracts.json')) {
+                return { error: `No contracts.json for group "${name}". Run group_sync first.` };
+            }
+            return { error: loaded.error };
         }
+        const { registry, skippedCorrupt } = loaded;
         let contracts = registry.contracts;
         if (params.type)
             contracts = contracts.filter((c) => c.type === params.type);
@@ -73,21 +187,106 @@ export class GroupService {
             ]));
             contracts = contracts.filter((c) => !matchedIds.has(`${c.repo}::${c.contractId}`));
         }
-        return { contracts, crossLinks: registry.crossLinks };
+        const out = { contracts, crossLinks: registry.crossLinks };
+        if (skippedCorrupt > 0)
+            out.skippedCorrupt = skippedCorrupt;
+        return out;
+    }
+    async groupImpact(params) {
+        const { runGroupImpact } = await import('./cross-impact.js');
+        return runGroupImpact({ port: this.port, gitnexusDir: getDefaultGitnexusDir() }, params);
+    }
+    async groupContext(params) {
+        const name = String(params.name ?? '').trim();
+        const target = typeof params.target === 'string' ? params.target.trim() : '';
+        const uid = typeof params.uid === 'string' ? params.uid.trim() : undefined;
+        const file_path = typeof params.file_path === 'string' ? params.file_path : undefined;
+        const include_content = Boolean(params.include_content);
+        if (params.service !== undefined &&
+            params.service !== null &&
+            String(params.service).trim() === '') {
+            return { group: name || '', error: 'service must not be an empty string', results: [] };
+        }
+        const servicePrefix = normalizeServicePrefix(params.service);
+        const subgroup = typeof params.subgroup === 'string' ? params.subgroup : undefined;
+        const subgroupExact = params.subgroupExact === true;
+        if (!name) {
+            return { group: '', error: 'name is required', results: [] };
+        }
+        if (!uid && !target) {
+            return { group: name, error: 'target or uid is required', results: [] };
+        }
+        const groupDir = getGroupDir(getDefaultGitnexusDir(), name);
+        let config;
+        try {
+            config = await loadGroupConfig(groupDir);
+        }
+        catch (e) {
+            return {
+                group: name,
+                target: target || uid,
+                service: servicePrefix,
+                error: e instanceof Error ? e.message : String(e),
+                results: [],
+            };
+        }
+        const memberEntries = Object.entries(config.repos).filter(([repoPath]) => repoInSubgroup(repoPath, subgroup, subgroupExact));
+        // Per-repo work is independent (each repo opens its own DB handle and the
+        // group-level result preserves repo iteration order via the indexed map).
+        // Errors are caught per repo so one slow/failed member does not block the rest.
+        const results = await Promise.all(memberEntries.map(async ([repoPath, registryName]) => {
+            try {
+                const repoObj = await this.port.resolveRepo(registryName);
+                const payload = await this.port.context(repoObj, {
+                    name: target || undefined,
+                    uid,
+                    file_path,
+                    include_content,
+                });
+                if (servicePrefix) {
+                    const st = payload?.status;
+                    const sym = payload?.symbol;
+                    if (st === 'found' && !fileMatchesServicePrefix(sym?.filePath, servicePrefix)) {
+                        return { repoPath, registryName, payload: {} };
+                    }
+                }
+                return { repoPath, registryName, payload };
+            }
+            catch (e) {
+                return {
+                    repoPath,
+                    registryName,
+                    payload: { error: e instanceof Error ? e.message : String(e) },
+                };
+            }
+        }));
+        return {
+            group: name,
+            target: target || uid,
+            service: servicePrefix,
+            results,
+        };
     }
     async groupQuery(params) {
         const name = String(params.name ?? '').trim();
         const queryText = String(params.query ?? '').trim();
         if (!name || !queryText)
             return { error: 'name and query are required' };
+        if (params.service !== undefined &&
+            params.service !== null &&
+            String(params.service).trim() === '') {
+            return { error: 'service must not be an empty string' };
+        }
+        const servicePrefix = normalizeServicePrefix(params.service);
         const limit = typeof params.limit === 'number' && params.limit > 0 ? params.limit : 5;
         const subgroup = typeof params.subgroup === 'string' ? params.subgroup : undefined;
+        const subgroupExact = params.subgroupExact === true;
         const groupDir = getGroupDir(getDefaultGitnexusDir(), name);
         const config = await loadGroupConfig(groupDir);
-        const perRepo = [];
-        for (const [repoPath, registryName] of Object.entries(config.repos)) {
-            if (!repoInSubgroup(repoPath, subgroup))
-                continue;
+        const memberEntries = Object.entries(config.repos).filter(([repoPath]) => repoInSubgroup(repoPath, subgroup, subgroupExact));
+        // Per-repo query is independent; run them concurrently and isolate
+        // failures so one slow/failed member does not block the rest.
+        const perRepo = await Promise.all(memberEntries.map(async ([repoPath, registryName]) => {
             try {
                 const repoObj = await this.port.resolveRepo(registryName);
                 const queryResult = (await this.port.query(repoObj, {
@@ -96,18 +295,20 @@ export class GroupService {
                     max_symbols: 10,
                     include_content: false,
                 }));
-                const processes = queryResult.processes || [];
+                const processes = servicePrefix
+                    ? filterQueryByServicePrefix(queryResult, servicePrefix).processes
+                    : queryResult.processes || [];
                 const scored = processes.map((p, idx) => ({
                     ...p,
                     _rrf_score: 1 / (idx + 1 + 60),
                     _repo: repoPath,
                 }));
-                perRepo.push({ repo: repoPath, score: 0, processes: scored });
+                return { repo: repoPath, score: 0, processes: scored };
             }
             catch {
-                perRepo.push({ repo: repoPath, score: 0, processes: [] });
+                return { repo: repoPath, score: 0, processes: [] };
             }
-        }
+        }));
         const allProcesses = perRepo.flatMap((r) => r.processes);
         allProcesses.sort((a, b) => b._rrf_score - a._rrf_score);
         const topN = allProcesses.slice(0, limit);
@@ -126,12 +327,10 @@ export class GroupService {
         const config = await loadGroupConfig(groupDir);
         const registry = await readContractRegistry(groupDir);
         const repoStatuses = {};
-        const fsp = await import('node:fs/promises');
-        const pathMod = await import('node:path');
         for (const [repoPath, registryName] of Object.entries(config.repos)) {
             try {
                 const repoObj = await this.port.resolveRepo(registryName);
-                const metaPath = pathMod.join(repoObj.storagePath, 'meta.json');
+                const metaPath = path.join(repoObj.storagePath, 'meta.json');
                 const metaRaw = await fsp.readFile(metaPath, 'utf-8').catch(() => '{}');
                 const meta = JSON.parse(metaRaw);
                 const staleness = meta.lastCommit

package/dist/core/group/types.d.ts

@@ -83,6 +83,8 @@ export interface RepoHandle {
     repoPath: string;
     storagePath: string;
 }
+/** Why local impact or fan-out stopped early (e.g. wall-clock budget exhausted). */
+export type GroupImpactTruncationReason = 'timeout' | 'partial';
 export interface GroupImpactResult {
     local: unknown;
     group: string;
@@ -97,6 +99,34 @@ export interface GroupImpactResult {
         cross_repo_hits: number;
     };
     risk: string;
+    /**
+     * Milliseconds budget applied to the **Phase 1 local impact** leg (`safeLocalImpact`).
+     * If the walk hits this wall first, expect `truncationReason: 'timeout'` and a partial `local` payload.
+     */
+    timeoutMs?: number;
+    /** Present when local impact or fan-out stopped early (timeout, graph cap, etc.). */
+    truncationReason?: GroupImpactTruncationReason;
+    /**
+     * Human-readable note when `crossDepth` was clamped (e.g. multi-hop not implemented yet).
+     */
+    crossDepthWarning?: string;
+}
+/** One repo’s `context` tool payload in a group-scoped context run. */
+export interface GroupContextRepoEntry {
+    repoPath: string;
+    registryName: string;
+    payload: unknown;
+}
+/**
+ * Aggregated group `context`: explicit per-repo rows (no merged symbol payloads).
+ * Use top-level `error` only for unrecoverable failures, not for “no matches” or service scope misses.
+ */
+export interface GroupContextResult {
+    group: string;
+    target?: string;
+    service?: string;
+    error?: string;
+    results: GroupContextRepoEntry[];
 }
 export interface CrossRepoImpact {
     repo: string;

package/dist/core/lbug/lbug-adapter.d.ts

@@ -139,6 +139,18 @@ export declare const loadVectorExtension: () => Promise<void>;
  * @param stemmer - Stemming algorithm (default: 'porter')
  */
 export declare const createFTSIndex: (tableName: string, indexName: string, properties: string[], stemmer?: string) => Promise<void>;
+/**
+ * Lazy-create an FTS index, caching the fact in-process.
+ *
+ * Used by `queryFTS` so that `analyze` doesn't pay the ~440 ms × 5 fixed
+ * LadybugDB cost up-front (it dominates analyze on small repos). Instead,
+ * the cost is moved to the first `query`/`context` call in a session,
+ * where it's amortised across many lookups.
+ *
+ * Safe to call repeatedly — the in-process Set guarantees only the first
+ * call hits LadybugDB. `closeLbug` clears the cache so re-init starts fresh.
+ */
+export declare const ensureFTSIndex: (tableName: string, indexName: string, properties: string[], stemmer?: string) => Promise<void>;
 /**
  * Query a full-text search index
  * @param tableName - The node table name

package/dist/core/lbug/lbug-adapter.js

@@ -110,6 +110,17 @@ let conn = null;
 let currentDbPath = null;
 let ftsLoaded = false;
 let vectorExtensionLoaded = false;
+/**
+ * In-process cache of FTS indexes that have been ensured against the current
+ * connection. Prevents repeated `CALL CREATE_FTS_INDEX` round-trips inside a
+ * single CLI/MCP session — the first call to `ensureFTSIndex` for a given
+ * `(tableName, indexName)` pays the LadybugDB cost (~440 ms even when the
+ * index already exists on disk), subsequent calls are a Set lookup. Cleared
+ * by `closeLbug` so a re-init starts fresh.
+ *
+ * Key format: `${tableName}:${indexName}`.
+ */
+const ensuredFTSIndexes = new Set();
 /**
  * Check if an error indicates a missing column or table (schema-level problem)
  * rather than a transient/connection error. Used for legacy DB fallback logic.
@@ -935,6 +946,7 @@ export const closeLbug = async () => {
     currentDbPath = null;
     ftsLoaded = false;
     vectorExtensionLoaded = false;
+    ensuredFTSIndexes.clear();
 };
 export const isLbugReady = () => conn !== null && db !== null;
 /**
@@ -1097,6 +1109,24 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
         }
     }
 };
+/**
+ * Lazy-create an FTS index, caching the fact in-process.
+ *
+ * Used by `queryFTS` so that `analyze` doesn't pay the ~440 ms × 5 fixed
+ * LadybugDB cost up-front (it dominates analyze on small repos). Instead,
+ * the cost is moved to the first `query`/`context` call in a session,
+ * where it's amortised across many lookups.
+ *
+ * Safe to call repeatedly — the in-process Set guarantees only the first
+ * call hits LadybugDB. `closeLbug` clears the cache so re-init starts fresh.
+ */
+export const ensureFTSIndex = async (tableName, indexName, properties, stemmer = 'porter') => {
+    const key = `${tableName}:${indexName}`;
+    if (ensuredFTSIndexes.has(key))
+        return;
+    await createFTSIndex(tableName, indexName, properties, stemmer);
+    ensuredFTSIndexes.add(key);
+};
 /**
  * Query a full-text search index
  * @param tableName - The node table name

package/dist/core/run-analyze.js

@@ -11,7 +11,7 @@
 import path from 'path';
 import fs from 'fs/promises';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
+import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
 import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
 import { getCurrentCommit, hasGitDir, getInferredRepoName } from '../storage/git.js';
 import { generateAIContextFiles } from '../cli/ai-context.js';
@@ -123,17 +123,12 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             progress('lbug', pct, msg);
         });
         // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
-        progress('fts', 85, 'Creating search indexes...');
-        try {
-            await createFTSIndex('File', 'file_fts', ['name', 'content']);
-            await createFTSIndex('Function', 'function_fts', ['name', 'content']);
-            await createFTSIndex('Class', 'class_fts', ['name', 'content']);
-            await createFTSIndex('Method', 'method_fts', ['name', 'content']);
-            await createFTSIndex('Interface', 'interface_fts', ['name', 'content']);
-        }
-        catch {
-            // Non-fatal — FTS is best-effort
-        }
+        // FTS indexes are created lazily on first `query`/`context` call instead
+        // of eagerly here. On small repos / CI runners the LadybugDB
+        // CREATE_FTS_INDEX cost is ~440 ms × 5 (≈2 s) regardless of table size,
+        // which dominated `analyze` runtime and pushed Windows CI past its
+        // 30 s test budget. Lazy creation is implemented in
+        // `core/search/bm25-index.ts` via `ensureFTSIndex`.
         // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
         if (cachedEmbeddings.length > 0) {
             const cachedDims = cachedEmbeddings[0].embedding.length;

package/dist/core/search/bm25-index.d.ts

@@ -3,6 +3,12 @@
  *
  * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
+ *
+ * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
+ * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
+ * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
+ * small repos / CI runners) at the cost of paying that overhead on the
+ * first `query`/`context` call in a session.
  */
 export interface BM25SearchResult {
     filePath: string;

package/dist/core/search/bm25-index.js

@@ -3,8 +3,51 @@
  *
  * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
+ *
+ * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
+ * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
+ * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
+ * small repos / CI runners) at the cost of paying that overhead on the
+ * first `query`/`context` call in a session.
+ */
+import { queryFTS, ensureFTSIndex } from '../lbug/lbug-adapter.js';
+/**
+ * FTS schema served by `searchFTSFromLbug`. Centralised so that both the
+ * CLI/pipeline path and the MCP pool path use identical (table, index,
+ * properties) tuples and the lazy-create logic stays in one place.
  */
-import { queryFTS } from '../lbug/lbug-adapter.js';
+const FTS_INDEXES = [
+    { table: 'File', indexName: 'file_fts', properties: ['name', 'content'] },
+    { table: 'Function', indexName: 'function_fts', properties: ['name', 'content'] },
+    { table: 'Class', indexName: 'class_fts', properties: ['name', 'content'] },
+    { table: 'Method', indexName: 'method_fts', properties: ['name', 'content'] },
+    { table: 'Interface', indexName: 'interface_fts', properties: ['name', 'content'] },
+];
+/**
+ * Per-process cache for the MCP pool path: tracks which `(repoId, table)`
+ * pairs have been ensured. The CLI/pipeline path gets its own cache inside
+ * `lbug-adapter.ts` keyed by table/index, scoped to the singleton connection.
+ */
+const ensuredPoolFTS = new Set();
+async function ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties) {
+    const key = `${repoId}:${table}:${indexName}`;
+    if (ensuredPoolFTS.has(key))
+        return;
+    const propList = properties.map((p) => `'${p}'`).join(', ');
+    try {
+        await executor(`CALL CREATE_FTS_INDEX('${table}', '${indexName}', [${propList}], stemmer := 'porter')`);
+    }
+    catch (e) {
+        // 'already exists' is the happy path (index persists on disk between
+        // process invocations) — anything else we swallow because FTS is
+        // best-effort: queryFTS itself returns [] on missing-index errors.
+        const msg = String(e?.message ?? '');
+        if (!msg.includes('already exists')) {
+            // Best-effort — continue without index, queryFTS will fall back to [].
+        }
+    }
+    ensuredPoolFTS.add(key);
+}
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
  * Returns the same shape as core queryFTS (from LadybugDB adapter).
@@ -52,6 +95,11 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         // The MCP pool supports multiple connections, but FTS is best run serially.
         const { executeQuery } = await import('../lbug/pool-adapter.js');
         const executor = (cypher) => executeQuery(repoId, cypher);
+        // Lazy-create FTS indexes on first query for this repo (analyze no longer
+        // creates them up-front, so we ensure them here). Cached per-process.
+        for (const { table, indexName, properties } of FTS_INDEXES) {
+            await ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties);
+        }
         fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
         functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
         classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
@@ -59,7 +107,11 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
     }
     else {
-        // Use core lbug adapter (CLI / pipeline context) — also sequential for safety
+        // Use core lbug adapter (CLI / pipeline context) — also sequential for safety.
+        // Lazy-create FTS indexes on first query (analyze no longer does it).
+        for (const { table, indexName, properties } of FTS_INDEXES) {
+            await ensureFTSIndex(table, indexName, [...properties]).catch(() => { });
+        }
         fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []);
         functionResults = await queryFTS('Function', 'function_fts', query, limit, false).catch(() => []);
         classResults = await queryFTS('Class', 'class_fts', query, limit, false).catch(() => []);

package/dist/mcp/local/local-backend.d.ts

@@ -236,11 +236,26 @@ export declare class LocalBackend {
         includeTests: boolean;
     }): Promise<any | null>;
     private handleGroupTool;
+    /**
+     * Dispatch impact/query/context when `repo` is `@groupName` or `@groupName/memberPath`
+     * (group mode — not the global indexed-repo `repo` parameter).
+     */
+    private callToolAtGroupRepo;
     private groupList;
     private groupSync;
-    private groupContracts;
-    private groupQuery;
-    private groupStatus;
+    /**
+     * MCP resource body for `gitnexus://group/{name}/contracts` (Issue #794).
+     */
+    readGroupContractsResource(groupName: string, filter: {
+        type?: string;
+        repo?: string;
+        unmatchedOnly?: boolean;
+    }): Promise<string>;
+    /**
+     * MCP resource body for `gitnexus://group/{name}/status` (Issue #794).
+     */
+    readGroupStatusResource(groupName: string): Promise<string>;
+    private static formatGroupResourcePayload;
     /**
      * Fetch Route nodes with their consumers in a single query.
      * Shared by routeMap and shapeCheck to avoid N+1 query patterns.