gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -19,12 +19,13 @@ import { LBUG_ID_PROBE_BATCH_SIZE, LBUG_QUERY_BATCH_SIZE } from '../../core/lbug
 import { chunk, mapConcurrent } from '../../lib/utils.js';
 import { pathSuffixOf } from './path-predicate.js';
 import { toOneBasedLine } from '../../core/ingestion/utils/line-base.js';
+import { isTestFilePath } from '../../core/ingestion/utils/test-file-path.js';
 import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/lbug-config.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
-import { parseDiffHunks, coalesceHunksByPath, hunksOverlapRange, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
+import { parseDiffHunks, coalesceHunksByPath, hunksOverlapRange, findGitRootByDotGit, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
 import { realpathSync } from 'fs';
 import { listRegisteredRepos, cleanupOldKuzuFiles, canonicalizePath, getStoragePaths, loadMeta, RegistryAmbiguousTargetError, } from '../../storage/repo-manager.js';
 import { GroupService, } from '../../core/group/service.js';
@@ -190,30 +191,8 @@ function normalizeToolParams(method, params) {
 }
 // AI context generation is CLI-only (gitnexus analyze)
 // import { generateAIContextFiles } from '../../cli/ai-context.js';
-/**
- * Quick test-file detection for filtering impact results.
- * Matches common test file patterns across all supported languages.
- */
-export function isTestFilePath(filePath) {
-    if (!filePath)
-        return false;
-    const p = filePath.toLowerCase().replace(/\\/g, '/');
-    return (p.includes('.test.') ||
-        p.includes('.spec.') ||
-        p.includes('__tests__/') ||
-        p.includes('__mocks__/') ||
-        p.includes('/test/') ||
-        p.includes('/tests/') ||
-        p.includes('/testing/') ||
-        p.includes('/fixtures/') ||
-        p.endsWith('_test.go') ||
-        p.endsWith('_test.py') ||
-        p.endsWith('_spec.rb') ||
-        p.endsWith('_test.rb') ||
-        p.includes('/spec/') ||
-        p.includes('/test_') ||
-        p.includes('/conftest.'));
-}
+/** Shared predicate; re-exported so MCP importers keep the old public name. */
+export { isTestFilePath };
 /** Valid LadybugDB node labels for safe Cypher query construction */
 export const VALID_NODE_LABELS = new Set([
     'File',
@@ -245,6 +224,7 @@ export const VALID_NODE_LABELS = new Set([
     'Module',
     'Route',
     'Tool',
+    'Destination',
 ]);
 /** Valid relation types for impact analysis filtering */
 export const VALID_RELATION_TYPES = new Set([
@@ -288,6 +268,15 @@ export const VALID_RELATION_TYPES = new Set([
     // impact defaults do not silently widen; target enrichment still surfaces
     // advised/proxied state on ordinary impact calls.
     'ADVISED_BY',
+    // Async messaging edges. Valid for an explicit `relationTypes` filter —
+    // "who else publishes to the topic this handler reads?" — but deliberately
+    // NOT in the default impact relTypes, on the HANDLES_ROUTE precedent: a
+    // shared broker destination is a high-degree hub, and admitting it by
+    // default would pull every unrelated producer of a busy topic into an
+    // ordinary blast radius. No IMPACT_RELATION_CONFIDENCE entry either, so the
+    // 0.5 unknown-type floor applies (WRAPS/FETCHES/INJECTS precedent).
+    'PUBLISHES_TO',
+    'CONSUMES_FROM',
 ]);
 /**
  * Relation types the #1858 epistemic-boundary probe keys on. Kept as
@@ -666,6 +655,9 @@ export function buildDetectChangesDiffArgs(scope, baseRef) {
         'diff',
         '--ignore-cr-at-eol',
         '--no-ext-diff',
+        // color.ui=always prefixes `+++ b/` with ANSI, so parseDiffHunks sees zero
+        // files and the CLI used to print a clean "No changes detected." (#3131).
+        '--color=never',
         '--src-prefix=a/',
         '--dst-prefix=b/',
     ];
@@ -694,6 +686,18 @@ export function buildDetectChangesDiffArgs(scope, baseRef) {
  * (#2054).
  */
 export const REPO_ID_HASH_LENGTH = 6;
+const routeRuntimeEvidence = (route) => ({
+    confirmed: route.runtimeConfirmed,
+    ...(route.runtimeSource === null ? {} : { source: route.runtimeSource }),
+    ...(route.runtimeStatus === null ? {} : { status: route.runtimeStatus }),
+});
+const isMissingRouteRuntimePropertyError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return (['runtimeConfirmed', 'runtimeSource', 'runtimeStatus'].some((property) => message.includes(property)) &&
+        (/cannot find property/i.test(message) ||
+            /property .* does not exist/i.test(message) ||
+            /property .* not found/i.test(message)));
+};
 /**
  * Validate and normalise `list_repos` pagination arguments.
  *
@@ -1179,23 +1183,56 @@ export class LocalBackend {
      * - If only 1 repo, use it
      * - If 0 or multiple without param, throw with helpful message
      *
-     * On a miss, re-reads the registry once in case a new repo was indexed
-     * while the MCP server was running.
+     * Re-reads the registry before an omitted implicit target or after an
+     * explicit miss, so long-running servers see newly indexed repositories.
      */
     async resolveRepo(repoParam, branch) {
-        let refreshedAfterAmbiguity = false;
+        return this.selectToolRepository(repoParam, branch);
+    }
+    /**
+     * Internal resolver variant for CLI/MCP tool routing and discovery.
+     * - If repoParam is given, match by name or path
+     * - If only 1 repo, use it
+     * - If multiple repos exist and repoParam is omitted, callers may opt in to
+     *   the registered repo containing process.cwd()
+     * - If 0 repos exist, or cwd cannot disambiguate multiple repos, throw
+     *
+     * Omitted-repo resolution re-reads the registry before accepting any
+     * implicit target, including a cached singleton. A caller that just obtained
+     * a fresh registry snapshot may disable that refresh explicitly.
+     */
+    async selectToolRepository(repoParam, branch, options = {}) {
+        const allowCwdDefault = options.allowCwdDefault === true;
+        const mayRefresh = options.refreshRegistry !== false;
+        let refreshed = false;
+        // A cached singleton is also an implicit choice: another process may have
+        // registered a second repo since init, which must not let a repo-less
+        // mutating call bypass the multi-repo ambiguity guard.
+        if (!repoParam && mayRefresh) {
+            await this.refreshRepos();
+            refreshed = true;
+        }
         let result;
         try {
-            result = this.resolveRepoFromCache(repoParam);
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
         }
         catch (err) {
             if (!(err instanceof RegistryAmbiguousTargetError))
                 throw err;
+            if (!mayRefresh || refreshed)
+                throw err;
             // Stale in-memory duplicate siblings can linger after unregister; refresh
             // once before re-throwing so a resolved registry can disambiguate (#1658).
             await this.refreshRepos();
-            refreshedAfterAmbiguity = true;
-            result = this.resolveRepoFromCache(repoParam);
+            refreshed = true;
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
+        }
+        // Explicit misses retain the existing one-refresh retry. Omitted targets
+        // already refreshed above unless a same-snapshot caller opted out.
+        if (!result && mayRefresh && !refreshed) {
+            await this.refreshRepos();
+            refreshed = true;
+            result = this.resolveRepoFromCache(repoParam, allowCwdDefault);
         }
         if (result) {
             // Issue: silent graph drift across sibling clones.
@@ -1209,15 +1246,6 @@ export class LocalBackend {
             });
             return this.applyBranchScope(result, branch);
         }
-        // Miss — refresh registry and try once more (skip if already refreshed above)
-        if (!refreshedAfterAmbiguity) {
-            await this.refreshRepos();
-        }
-        const retried = this.resolveRepoFromCache(repoParam);
-        if (retried) {
-            this.maybeWarnSiblingDrift(retried).catch(() => { });
-            return this.applyBranchScope(retried, branch);
-        }
         // Still no match — throw with helpful message
         if (this.repos.size === 0) {
             throw new Error('No indexed repositories. Run: gitnexus analyze');
@@ -1350,7 +1378,7 @@ export class LocalBackend {
      * Throws {@link RegistryAmbiguousTargetError} when `repoParam` matches
      * multiple handles by name and cwd cannot disambiguate (#1658).
      */
-    resolveRepoFromCache(repoParam) {
+    resolveRepoFromCache(repoParam, allowCwdDefault = false) {
         if (this.repos.size === 0)
             return null;
         if (repoParam) {
@@ -1379,6 +1407,9 @@ export class LocalBackend {
             if (nameMatches.length === 1)
                 return nameMatches[0];
             if (nameMatches.length > 1) {
+                // Explicit duplicate aliases retain the legacy fail-closed contract:
+                // only an exact cwd Git-root match may disambiguate them. Deepest path
+                // containment is reserved for an omitted read-only repo (#3073).
                 const cwdPick = this.pickRepoHandleForCwd(nameMatches);
                 if (cwdPick)
                     return cwdPick;
@@ -1403,26 +1434,46 @@ export class LocalBackend {
         if (this.repos.size === 1) {
             return this.repos.values().next().value;
         }
+        if (allowCwdDefault) {
+            const cwdPick = this.pickRepoHandleForCwd([...this.repos.values()], true);
+            if (cwdPick)
+                return cwdPick;
+        }
         return null; // Multiple repos, no param — ambiguous
     }
     /**
-     * Prefer the indexed repo whose path matches the git root of process.cwd().
+     * Match process.cwd() against indexed repositories.
      *
-     * In MCP stdio server mode, `process.cwd()` is the server's launch directory,
-     * not the agent client's cwd. If the server was started from an unrelated
-     * directory, `getGitRoot` returns null and duplicate-name resolution throws
-     * {@link RegistryAmbiguousTargetError} — callers should pass an absolute path.
+     * Explicit duplicate aliases use exact Git-root matching only. Omitted
+     * read-only calls opt into deepest containing-path selection. In that mode a
+     * candidate must not sit above cwd's Git root, so an unindexed nested checkout
+     * cannot fall through to an indexed ancestor. The `.git` ancestor fallback
+     * preserves that boundary when the git executable is unavailable.
      */
-    pickRepoHandleForCwd(candidates) {
-        const cwdRoot = getGitRoot(process.cwd());
-        if (!cwdRoot)
+    pickRepoHandleForCwd(candidates, allowContaining = false) {
+        const cwd = process.cwd();
+        const normalize = (value) => {
+            const canonical = canonicalizePath(value);
+            return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+        };
+        const isSameOrDescendant = (parent, child) => child === parent ||
+            child.startsWith(parent.endsWith(path.sep) ? parent : `${parent}${path.sep}`);
+        const canonicalCwd = normalize(cwd);
+        const cwdRoot = getGitRoot(cwd) ?? findGitRootByDotGit(cwd);
+        const canonicalRoot = cwdRoot ? normalize(cwdRoot) : null;
+        if (allowContaining) {
+            const containing = candidates
+                .map((handle) => ({ handle, repoPath: normalize(handle.repoPath) }))
+                .filter(({ repoPath }) => isSameOrDescendant(repoPath, canonicalCwd))
+                .filter(({ repoPath }) => !canonicalRoot || isSameOrDescendant(canonicalRoot, repoPath))
+                .sort((a, b) => b.repoPath.length - a.repoPath.length);
+            if (containing.length > 0)
+                return containing[0].handle;
+        }
+        if (!canonicalRoot)
             return null;
-        const canonicalCwd = canonicalizePath(cwdRoot);
         const cwdMatches = candidates.filter((handle) => {
-            const stored = canonicalizePath(handle.repoPath);
-            return process.platform === 'win32'
-                ? stored.toLowerCase() === canonicalCwd.toLowerCase()
-                : stored === canonicalCwd;
+            return normalize(handle.repoPath) === canonicalRoot;
         });
         return cwdMatches.length === 1 ? cwdMatches[0] : null;
     }
@@ -1819,7 +1870,7 @@ export class LocalBackend {
         }
         // Resolve repo from optional param (re-reads registry on miss). An optional
         // `branch` param scopes the resolved handle to that branch's index (#2106).
-        const repo = await this.resolveRepo(p.repo, p.branch);
+        const repo = await this.selectToolRepository(p.repo, p.branch, { allowCwdDefault: method !== 'rename' });
         switch (method) {
             case 'query':
                 return this.withToolStaleness(repo, await this.query(repo, p));
@@ -5972,8 +6023,8 @@ export class LocalBackend {
             // retains the strongest evidence, the safer default for a blast-radius
             // tool. `sourceId` closes the order for edges that tie on both.
             const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
+                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence, r.staticGated AS staticGated`
+                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence, r.staticGated AS staticGated`;
             try {
                 const related = await executeParameterized(repo.lbugPath, query, {
                     frontierIds: frontier,
@@ -5988,6 +6039,9 @@ export class LocalBackend {
                     relType: rel.relType || rel[5],
                     confidence: rel.confidence ?? rel[6],
                     sourceId: String(rel.sourceId ?? rel[0] ?? ''),
+                    // Set only by languages that compute static gating (Zig); null/undefined
+                    // from older indexes or other languages reads as live.
+                    ...((rel.staticGated ?? rel[7]) === true ? { staticGated: true } : {}),
                 }));
                 // The pdg bridge is the ONE consumer here that accumulates sequentially
                 // rather than per-node: at depth ≥ 2 an edge inherits
@@ -6061,6 +6115,9 @@ export class LocalBackend {
                         filePath: edge.filePath,
                         relationType,
                         confidence: effectiveConfidence,
+                        // Surfaced, never acted on: traversal and ranking ignore the flag
+                        // (see GraphRelationship.staticGated). Absent = live or unmodelled.
+                        ...(edge.staticGated === true ? { staticGated: true } : {}),
                     });
                 }
             }
@@ -6736,6 +6793,17 @@ export class LocalBackend {
                 target: params.target,
                 direction: params.direction,
             };
+            // Forward the target-selector params like the trace branch above.
+            // @group impact used to drop target_uid/file_path/kind here, so a name
+            // shared by same-named Api/Impl/Controller layers resolved ambiguously
+            // in the member repo and the documented "re-call with target_uid"
+            // disambiguation loop (impact tool schema) never worked in group mode.
+            if (typeof params.target_uid === 'string')
+                impactArgs.target_uid = params.target_uid;
+            if (typeof params.file_path === 'string')
+                impactArgs.file_path = params.file_path;
+            if (typeof params.kind === 'string')
+                impactArgs.kind = params.kind;
             if (params.maxDepth !== undefined)
                 impactArgs.maxDepth = params.maxDepth;
             if (params.crossDepth !== undefined)
@@ -6862,7 +6930,7 @@ export class LocalBackend {
      * Shared by routeMap and shapeCheck to avoid N+1 query patterns.
      */
     async fetchRoutesWithConsumers(repoId, routeFilter, params) {
-        const rows = await executeParameterized(repoId, `
+        const routeQuery = (includeRuntimeEvidence) => `
       MATCH (n:Route)
       WHERE n.id STARTS WITH 'Route:' ${routeFilter}
       OPTIONAL MATCH (consumer)-[r:CodeRelation]->(n)
@@ -6870,8 +6938,19 @@ export class LocalBackend {
       RETURN n.id AS routeId, n.name AS routeName, n.filePath AS handlerFile,
              n.responseKeys AS responseKeys, n.errorKeys AS errorKeys, n.middleware AS middleware,
              consumer.name AS consumerName, consumer.filePath AS consumerFile,
-             r.reason AS fetchReason, n.method AS method
-    `, params);
+             r.reason AS fetchReason, n.method AS method${includeRuntimeEvidence
+            ? ', n.runtimeConfirmed AS runtimeConfirmed, n.runtimeSource AS runtimeSource, n.runtimeStatus AS runtimeStatus'
+            : ''}
+    `;
+        let rows;
+        try {
+            rows = await executeParameterized(repoId, routeQuery(true), params);
+        }
+        catch (error) {
+            if (!isMissingRouteRuntimePropertyError(error))
+                throw error;
+            rows = await executeParameterized(repoId, routeQuery(false), params);
+        }
         // Strip wrapping quotes from DB array elements — CSV COPY stores ['key'] which
         // LadybugDB may return as "'key'" rather than "key"
         const stripQuotes = (keys) => keys ? keys.map((k) => k.replace(/^['"]|['"]$/g, '')) : null;
@@ -6891,6 +6970,9 @@ export class LocalBackend {
             // resource). Appended last in RETURN so positional fallbacks for the
             // consumer/reason columns above stay stable.
             const method = row.method ?? row[9] ?? null;
+            const runtimeConfirmed = (row.runtimeConfirmed ?? row[10]) === true;
+            const runtimeSource = row.runtimeSource ?? row[11] ?? null;
+            const runtimeStatus = row.runtimeStatus ?? row[12] ?? null;
             if (!routeMap.has(id)) {
                 routeMap.set(id, {
                     id,
@@ -6900,6 +6982,9 @@ export class LocalBackend {
                     responseKeys,
                     errorKeys,
                     middleware,
+                    runtimeConfirmed,
+                    runtimeSource,
+                    runtimeStatus,
                     consumers: [],
                 });
             }
@@ -6981,6 +7066,7 @@ export class LocalBackend {
                 route: r.name,
                 method: r.method,
                 handler: r.filePath,
+                runtimeEvidence: routeRuntimeEvidence(r),
                 middleware: r.middleware || [],
                 consumers: r.consumers,
                 flows: flowMap.get(r.id) || [],
@@ -7036,6 +7122,7 @@ export class LocalBackend {
                 route: r.name,
                 method: r.method,
                 handler: r.filePath,
+                runtimeEvidence: routeRuntimeEvidence(r),
                 ...(responseKeys.length > 0 ? { responseKeys } : {}),
                 ...(errorKeys.length > 0 ? { errorKeys } : {}),
                 consumers,
@@ -7199,6 +7286,7 @@ export class LocalBackend {
                 route: r.name,
                 method: r.method,
                 handler: r.filePath,
+                runtimeEvidence: routeRuntimeEvidence(r),
                 responseShape: {
                     success: responseKeys,
                     error: errorKeys,

package/dist/mcp/repository-policy.d.ts

@@ -20,10 +20,14 @@ export declare class McpRepositoryPolicy {
     private repoForArgs;
     private normalizeToolArgs;
     private listAllowedRepos;
-    requiresExplicitRepo(backend: LocalBackend): Promise<boolean>;
+    toolSchemaRepoRequirements(backend: LocalBackend): Promise<{
+        readOnlyRequiresRepo: boolean;
+        mutatingRequiresRepo: boolean;
+    }>;
     private listReposPage;
     private callTool;
     private resolveRepo;
+    private selectToolRepository;
     assertResourceUri(uri: string): void;
     resourceTemplateAllowed(uriTemplate: string): boolean;
     toolAllowed(toolName: string): boolean;

package/dist/mcp/repository-policy.js

@@ -134,10 +134,40 @@ export class McpRepositoryPolicy {
             };
         });
     }
-    async requiresExplicitRepo(backend) {
-        if (this.defaultRepo)
-            return false;
-        return (await this.listAllowedRepos(backend)).length > 1;
+    async toolSchemaRepoRequirements(backend) {
+        if (this.defaultRepo) {
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
+        }
+        // Runtime selection is based on the configured allowlist, not on which
+        // entries happen to remain visible in a later registry refresh. Keep the
+        // advertised schema aligned with repoForArgs() when that listing shrinks.
+        if (this.restricted) {
+            const requiresRepo = this.allowed.length > 1;
+            return {
+                readOnlyRequiresRepo: requiresRepo,
+                mutatingRequiresRepo: requiresRepo,
+            };
+        }
+        // One fresh listing supplies both schema decisions. Besides keeping the
+        // advertised contract internally consistent, this avoids doing two full
+        // per-repo staleness fan-outs for every tools/list request.
+        const visibleRepos = await this.listAllowedRepos(backend);
+        if (visibleRepos.length <= 1) {
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
+        }
+        try {
+            // listAllowedRepos() refreshed this backend immediately above. Resolve
+            // against that exact cache snapshot instead of racing another registry
+            // read; only read-only schemas may advertise the cwd-derived default.
+            await backend.selectToolRepository(undefined, undefined, {
+                allowCwdDefault: true,
+                refreshRegistry: false,
+            });
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: true };
+        }
+        catch {
+            return { readOnlyRequiresRepo: true, mutatingRequiresRepo: true };
+        }
     }
     async listReposPage(backend, params) {
         const { limit, offset } = parseListReposPagination(params, {
@@ -186,6 +216,17 @@ export class McpRepositoryPolicy {
         const selected = this.repoForArgs(repo === undefined ? undefined : { repo });
         return backend.resolveRepo(selected?.path, branch);
     }
+    async selectToolRepository(backend, repo, branch, options) {
+        if (!this.configured)
+            return backend.selectToolRepository(repo, branch, options);
+        if (!this.restricted) {
+            return backend.selectToolRepository(repo ?? this.defaultRepo?.path, branch, options);
+        }
+        const selected = this.repoForArgs(repo === undefined ? undefined : { repo });
+        // Restricted policies never allow cwd to select outside the configured
+        // set; once policy supplies an explicit path, the public resolver is enough.
+        return backend.resolveRepo(selected?.path, branch);
+    }
     assertResourceUri(uri) {
         if (!this.restricted)
             return;
@@ -255,6 +296,9 @@ export class McpRepositoryPolicy {
                 if (property === 'resolveRepo') {
                     return (repo, branch) => policy.resolveRepo(target, repo, branch);
                 }
+                if (property === 'selectToolRepository') {
+                    return (repo, branch, options) => policy.selectToolRepository(target, repo, branch, options);
+                }
                 if (property === 'getContext' && policy.restricted) {
                     return (repoId) => {
                         if (!repoId || !policy.uniqueAllowedContextNames.has(repoId.toLowerCase()))

package/dist/mcp/resources.js

@@ -254,7 +254,8 @@ async function getReposResource(backend) {
     }
     if (repos.length > 1) {
         lines.push('');
-        lines.push('# Multiple repos indexed. Use repo parameter in tool calls:');
+        lines.push('# Multiple repos indexed. Read-only tools may omit repo when an MCP default is configured or GitNexus process.cwd() is inside one listed path without crossing an unindexed nested Git checkout.');
+        lines.push('# Otherwise—and for mutating tools without an MCP default—pass repo explicitly:');
         lines.push(`# query({search_query: "auth", repo: "${repos[0].name}"})`);
     }
     return lines.join('\n');
@@ -297,6 +298,14 @@ async function getContextResource(backend, repoName) {
     lines.push(`  indexed_at: ${JSON.stringify(freshMeta?.indexedAt ?? null)}`);
     lines.push(`  runner_identity: ${JSON.stringify(freshMeta?.runnerIdentity ?? null)}`);
     lines.push(`  incomplete_reasons: ${JSON.stringify(incompleteReasons)}`);
+    lines.push(`  spring_actuator: ${JSON.stringify(freshMeta?.springActuator ?? null)}`);
+    // Surfaced beside the Actuator flag, and it matters more than that one does:
+    // Actuator only annotates nodes the source pass already found, whereas
+    // document reading MINTS destinations and edges that have no code site at
+    // all. Without this line an agent reading the context sees `Destination`
+    // nodes rooted at `asyncapi:`-prefixed pseudo-files with nothing to say where
+    // they came from.
+    lines.push(`  asyncapi_spec: ${JSON.stringify(freshMeta?.asyncApiSpec ?? null)}`);
     const indexedRunnerSchema = freshMeta?.runnerIdentity
         ?.schemaVersion;
     lines.push(`  runner_identity_schema_status: ${JSON.stringify(indexedRunnerSchema === ANALYZER_RUNNER_IDENTITY_SCHEMA_VERSION

package/dist/mcp/server.js

@@ -10,8 +10,8 @@
  * Tools: list_repos, query, cypher, context, impact, detect_changes, rename
  * Resources: repos, repo/{name}/context, repo/{name}/clusters, ...
  */
-import { createRequire } from 'module';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { packageVersion } from '../core/package-version.js';
 import { CompatibleStdioServerTransport } from './compatible-stdio-transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { GITNEXUS_TOOLS, REPO_SCOPED_TOOLS } from './tools.js';
@@ -70,11 +70,9 @@ export function createMCPServer(backend, options = {}) {
     }
     const repositoryPolicy = options.repositoryPolicy ?? McpRepositoryPolicy.unrestricted();
     const scopedBackend = repositoryPolicy.scopeBackend(backend);
-    const require = createRequire(import.meta.url);
-    const pkgVersion = require('../../package.json').version;
     const server = new Server({
         name: 'gitnexus',
-        version: pkgVersion,
+        version: packageVersion(),
     }, {
         capabilities: {
             tools: {},
@@ -136,11 +134,11 @@ export function createMCPServer(backend, options = {}) {
             };
         }
     });
-    // With multiple visible repositories and no process-wide default, make the
-    // routing requirement machine-readable. Agents then supply `repo` before the
-    // call instead of discovering the ambiguity through a failed tool response.
+    // Make the effective routing contract machine-readable. Read-only tools may
+    // use a cwd-derived default; mutating rename remains explicit unless policy
+    // supplies a single/default repository.
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        const requireRepo = await repositoryPolicy.requiresExplicitRepo(backend);
+        const { readOnlyRequiresRepo, mutatingRequiresRepo } = await repositoryPolicy.toolSchemaRepoRequirements(backend);
         return {
             tools: GITNEXUS_TOOLS.filter((tool) => (!readOnly || MCP_READ_ONLY_TOOLS.has(tool.name)) &&
                 repositoryPolicy.toolAllowed(tool.name))
@@ -148,7 +146,8 @@ export function createMCPServer(backend, options = {}) {
                 .map((tool) => ({
                 name: tool.name,
                 description: tool.description,
-                inputSchema: requireRepo && REPO_SCOPED_TOOLS.has(tool.name)
+                inputSchema: (tool.name === 'rename' ? mutatingRequiresRepo : readOnlyRequiresRepo) &&
+                    REPO_SCOPED_TOOLS.has(tool.name)
                     ? {
                         ...tool.inputSchema,
                         required: [...new Set([...tool.inputSchema.required, 'repo'])],