gitnexus 1.6.11-rc.8 → 1.6.11-rc.9

package/README.md

@@ -204,7 +204,7 @@ Your AI agent gets **17 tools** (15 per-repo + 2 group) automatically:
 | `group_list`     | List configured repository groups                                      |
 | `group_sync`     | Rebuild a group's Contract Registry and cross-repo links               |
 
-> With one indexed repo, the `repo` param is optional. With multiple, specify which: `query({search_query: "auth", repo: "my-app"})`. Per-repo tools also take an optional `branch` for indexes pinned with `gitnexus analyze --branch`; omitting it queries the workspace index, which follows your checked-out working tree. `explain` and `pdg_query` need an index built with `gitnexus analyze --pdg`.
+> Read-only tools can omit `repo` when one repo is indexed, an MCP default is configured, or the GitNexus process cwd is inside a registered path without crossing into an unindexed nested Git checkout. Otherwise—and for mutating tools with multiple indexed repos and no MCP default—specify it explicitly: `query({search_query: "auth", repo: "my-app"})`. Per-repo tools also take an optional `branch` for indexes pinned with `gitnexus analyze --branch`; omitting it queries the workspace index, which follows your checked-out working tree. `explain` and `pdg_query` need an index built with `gitnexus analyze --pdg`.
 
 ## MCP Resources
 

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

@@ -371,10 +371,26 @@ export declare 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.
      */
     resolveRepo(repoParam?: string, branch?: string): Promise<RepoHandle>;
+    /**
+     * 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.
+     */
+    selectToolRepository(repoParam?: string, branch?: string, options?: {
+        allowCwdDefault?: boolean;
+        refreshRegistry?: boolean;
+    }): Promise<RepoHandle>;
     /**
      * Re-point a resolved repo handle at a specific branch index (#2106).
      *
@@ -409,12 +425,13 @@ export declare class LocalBackend {
      */
     private resolveRepoFromCache;
     /**
-     * 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.
      */
     private pickRepoHandleForCwd;
     private handleToRegistryEntry;

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

@@ -24,7 +24,7 @@ import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/l
 // 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';
@@ -1179,23 +1179,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 +1242,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 +1374,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 +1403,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 +1430,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 +1866,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));

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');

package/dist/mcp/server.js

@@ -136,11 +136,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 +148,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'])],

package/dist/mcp/tools.js

@@ -49,6 +49,8 @@ export const PDG_QUERY_MAX_LIMIT = 200;
 // Shared impact traversal depth cap. The MCP schema advertises this bound;
 // PDG direct backend callers also enforce it before running traversal.
 export const IMPACT_MAX_DEPTH = 32;
+const CWD_AWARE_REPO_OMISSION = 'Omit when only one repo is indexed, an MCP default is configured, or the GitNexus process cwd is inside a registered path without crossing an unindexed nested Git checkout; otherwise specify it explicitly.';
+const MUTATING_REPO_OMISSION = 'Omit only when one repo is indexed or an MCP default is configured; otherwise mutating tools require an explicit repo.';
 export const GITNEXUS_TOOLS = [
     {
         name: 'list_repos',
@@ -61,8 +63,10 @@ PAGINATION: Results are paginated so a large registry is not truncated by MCP/LL
 WHEN TO USE: First step when multiple repos are indexed, or to discover available repos.
 AFTER THIS: READ gitnexus://repo/{name}/context for the repo you want to work with.
 
-When multiple repos are indexed, you MUST specify the "repo" parameter
-on other tools (query, context, impact, etc.) to target the correct one.`,
+When multiple repos are indexed, repo-scoped read-only tools use the configured
+MCP default or the registered path containing the GitNexus process cwd, unless
+cwd has crossed into an unindexed nested Git checkout. If neither applies,
+specify the "repo" parameter explicitly.`,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
         inputSchema: {
             type: 'object',
@@ -148,7 +152,7 @@ SERVICE: optional monorepo path prefix (POSIX-style, case-sensitive segments). W
                 },
                 repo: {
                     type: 'string',
-                    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.',
+                    description: `Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>" (member path keys from group.yaml). ${CWD_AWARE_REPO_OMISSION}`,
                 },
                 service: {
                     type: 'string',
@@ -227,7 +231,7 @@ TIPS:
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: ['statement'],
@@ -290,7 +294,7 @@ SERVICE: optional monorepo path prefix (case-sensitive path segments). When "rep
                 },
                 repo: {
                     type: 'string',
-                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                    description: `Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". ${CWD_AWARE_REPO_OMISSION}`,
                 },
                 service: {
                     type: 'string',
@@ -334,7 +338,7 @@ Returns: changed symbols, affected processes, and a risk summary.
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],
@@ -373,7 +377,7 @@ A graph too large to analyze at all returns \`{ error, truncated: true }\` with
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],
@@ -410,7 +414,7 @@ Handles disambiguation via context()'s payload verbatim: an ambiguous symbol_nam
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${MUTATING_REPO_OMISSION}`,
                 },
             },
             required: ['new_name'],
@@ -542,7 +546,7 @@ SERVICE: optional monorepo path prefix (case-sensitive path segments). When "rep
                 },
                 repo: {
                     type: 'string',
-                    description: 'Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". Omit if only one repo is indexed.',
+                    description: `Indexed repository name or path, or group mode "@<groupName>" / "@<groupName>/<memberPath>". ${CWD_AWARE_REPO_OMISSION}`,
                 },
                 service: {
                     type: 'string',
@@ -630,7 +634,7 @@ Findings are deliberately NOT part of impact()'s traversal or the web schema —
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],
@@ -679,7 +683,7 @@ CONTRACT CAVEATS:
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: ['mode', 'target'],
@@ -703,7 +707,7 @@ Returns: route nodes with their handlers, middleware wrapper chains (e.g., withA
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],
@@ -721,7 +725,10 @@ Returns: tool nodes with their handler files and descriptions.`,
             type: 'object',
             properties: {
                 tool: { type: 'string', description: 'Filter by tool name. Omit for all tools.' },
-                repo: { type: 'string', description: 'Repository name or path.' },
+                repo: {
+                    type: 'string',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
+                },
             },
             required: [],
         },
@@ -744,7 +751,7 @@ Returns routes that have both detected response keys AND consumers. Shows top-le
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],
@@ -769,7 +776,10 @@ Response shape is keyed on how many routes match, not on the data: exactly one m
                     type: 'string',
                     description: 'Optional HTTP verb — GET, POST, PUT, PATCH, DELETE, etc. — to narrow a multi-verb route or file lookup to a single method. Returns an error if no matched route uses that verb.',
                 },
-                repo: { type: 'string', description: 'Repository name or path.' },
+                repo: {
+                    type: 'string',
+                    description: `Repository name or path. ${CWD_AWARE_REPO_OMISSION}`,
+                },
             },
             required: [],
         },
@@ -879,7 +889,7 @@ DESTINATION TRACE (cross-repo): for an "@groupName" trace, OMIT to/to_uid/to_fil
                 },
                 repo: {
                     type: 'string',
-                    description: 'Repository name or path, or "@groupName" / "@groupName/memberPath" for a cross-repo trace over a group. Omit if only one repo is indexed.',
+                    description: `Repository name or path, or "@groupName" / "@groupName/memberPath" for a cross-repo trace over a group. ${CWD_AWARE_REPO_OMISSION}`,
                 },
             },
             required: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.8",
+  "version": "1.6.11-rc.9",
   "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",

package/scripts/cross-platform-tests.ts

@@ -114,6 +114,9 @@ const PLATFORM_LOGIC = [
   // POSIX and Windows — the fail-closed path-claim semantics must hold on the
   // real windows-latest path implementation (#2419/#2420).
   'test/unit/server-api-repo-resolution.test.ts',
+  // #3073: cwd-based repository selection canonicalizes real paths, compares
+  // platform separators/case, and rejects nested Git-boundary fallthrough.
+  'test/unit/calltool-dispatch.test.ts',
   // The index write-lock (#2658) selects its backend by process.platform — the
   // OS socket lock (Windows named pipe / Linux abstract socket) vs the file
   // fallback — and its socket-backend describe block is gated to linux/win32.