diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a3a3cde4..be410062a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -118,6 +118,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In JavaScript and TypeScript, a default import now links to what the module's `export default` statement exports, wherever the statement sits in the file. Before, a module that declares its default, like `export default function Vans() {…}` or `export default class Store {…}`, had its default import linked to the first function it exports instead: in a React Router data-router app, where a page exports its `loader` or `action` above the page component, `import Vans, { loader as vansLoader } from './pages/Vans'` made the route `/vans` and every use of `Vans` lead to the loader. A component file that also exports a styled or memoized component no longer hands its default import to that component, and an anonymous default, like `export default function () {…}` or `export default () => …`, is no longer linked to a function exported beside it or nested inside it. A module loaded with `require('./x').default` is read the same way. Re-index JavaScript and TypeScript projects after upgrading.
 - In React and Vue, a tag for a component the file imports from a package, like `<Button>` from antd, `<Typography>` from `@mui/material/Typography`, `<Link>` from react-router-dom or `<Card>` from ant-design-vue, no longer links to a component, function or class in your repository that only shares its name. Before, the tag linked to whatever the repository had by that name, so `codegraph_explore`, callers and impact followed renders that never happen: in SigNoz, antd's `<Button>` tags showed up as callers of a styled link on its 404 page, and in Material UI dashboards like mantis and berry, `<Typography>` and `<Button>` tags showed up as callers of the theme's style overrides. A package here is one that a `package.json` above the file lists and that no file in the repository answers to. A tag imported through a path alias like `components/Modal`, from a workspace package of the repository, or under a name no `package.json` lists still links as before. Re-index React and Vue projects after upgrading.
 - In React with TypeScript, a component that renders a generic component and passes it type arguments, like outline's `<PaginatedList<Document> items={…} />` or excalidraw's `<DropdownMenuItemContentRadio<"contain" | "overlap"> …>`, now links to the component it renders. Before, a tag followed by type arguments was skipped, so the generic component looked unused by the screens that render it, and `codegraph_explore`'s call paths, callers and impact stopped short of it. Re-index React projects after upgrading.
+- In Go, a call into one of your own packages that shares its name with a standard-library package, like a project's `lib/errors`, `pkg/log` or `model/user`, now links: `errors.New(…)` or `log.Infof(…)` in a file that imports your package reaches your function, so its callers and impact are no longer nearly empty. The same goes for a struct built from such a package, like `types.Policy{…}`. A file that imports the standard library's package of that name is unaffected. Re-index Go projects after upgrading. (#2368)
 
 ## [1.6.2] - 2026-10-03
 
diff --git a/__tests__/go-stdlib-named-package.test.ts b/__tests__/go-stdlib-named-package.test.ts
new file mode 100644
index 000000000..ec2f7ea63
--- /dev/null
+++ b/__tests__/go-stdlib-named-package.test.ts
@@ -0,0 +1,172 @@
+/**
+ * A project package may carry a standard-library name — harbor's
+ * `src/lib/errors` and `src/lib/log`, a `pkg/types`, a `model/user`. What a
+ * file imports under that name decides whose `errors.New(…)` it writes: the
+ * project package's when the import path is inside one of the project's
+ * modules, the standard library's otherwise.
+ */
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+
+let root = '';
+let cg: CodeGraph;
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-go-stdname-'));
+  const files: Record<string, string> = {
+    'go.mod': 'module example.com/app\n\ngo 1.22\n',
+    'lib/errors/errors.go': `package errors
+
+type Error struct {
+	Code string
+}
+
+func New(msg string) *Error {
+	return &Error{Code: msg}
+}
+`,
+    'lib/log/log.go': `package log
+
+func Printf(format string, args ...any) {}
+`,
+    'svc/project.go': `package svc
+
+import (
+	"example.com/app/lib/errors"
+	"example.com/app/lib/log"
+)
+
+func Create(name string) *errors.Error {
+	log.Printf("create %s", name)
+	return errors.New(name)
+}
+
+func Literal() errors.Error {
+	return errors.Error{Code: "x"}
+}
+`,
+    'svc/renamed.go': `package svc
+
+import (
+	liberrors "example.com/app/lib/errors"
+)
+
+func Renamed() *liberrors.Error {
+	return liberrors.New("x")
+}
+`,
+    'svc/both.go': `package svc
+
+import (
+	stderrors "errors"
+
+	errors "example.com/app/lib/errors"
+)
+
+func Ours() *errors.Error {
+	return errors.New("x")
+}
+
+func Theirs() error {
+	return stderrors.New("y")
+}
+`,
+    'svc/std.go': `package svc
+
+import (
+	"errors"
+	"log"
+)
+
+func Std() error {
+	log.Printf("std")
+	return errors.New("std")
+}
+`,
+    'lib/log/v2/log.go': `package log
+
+func Infof(format string, args ...any) {}
+`,
+    // Unaliased imports whose paths end in a major version are known as `log`
+    // and `errors`; only the first is a package of this module.
+    'svc/versioned.go': `package svc
+
+import (
+	"example.com/app/lib/log/v2"
+	"github.com/acme/errors/v2"
+)
+
+func Versioned() error {
+	log.Infof("versioned")
+	return errors.New("outside")
+}
+`,
+    'svc/variable.go': `package svc
+
+type bag struct{}
+
+func (b *bag) Len() int { return 0 }
+
+func Variable(errors *bag) int {
+	errors.New("x")
+	return errors.Len()
+}
+`,
+  };
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+  cg = await CodeGraph.init(root, { index: true });
+});
+
+afterAll(() => {
+  cg?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+/** `kind file:name` of every edge leaving the function `fn` of `file`. */
+const edgesFrom = (file: string, fn: string) => {
+  const ids = cg.getNodesInFile(file).filter((n) => n.name === fn).map((n) => n.id);
+  return cg.getOutgoingEdgesFrom(ids).filter((e) => e.kind !== 'contains').map((e) => {
+    const target = cg.getNode(e.target)!;
+    return `${e.kind} ${target.filePath}:${target.qualifiedName}`;
+  });
+};
+
+describe('Go project package named like a standard-library package', () => {
+  it('resolves a call written through its import', () => {
+    const edges = edgesFrom('svc/project.go', 'Create');
+    expect(edges).toContain('calls lib/errors/errors.go:New');
+    expect(edges).toContain('calls lib/log/log.go:Printf');
+  });
+
+  it('resolves a composite literal of its type', () => {
+    expect(edgesFrom('svc/project.go', 'Literal')).toContain('instantiates lib/errors/errors.go:Error');
+  });
+
+  it('resolves through an import alias', () => {
+    expect(edgesFrom('svc/renamed.go', 'Renamed')).toContain('calls lib/errors/errors.go:New');
+  });
+
+  it('resolves when the alias is the standard-library name itself', () => {
+    expect(edgesFrom('svc/both.go', 'Ours')).toContain('calls lib/errors/errors.go:New');
+    expect(edgesFrom('svc/both.go', 'Theirs')).toEqual([]);
+  });
+
+  it('resolves through an unaliased import whose path ends in a major version', () => {
+    expect(edgesFrom('svc/versioned.go', 'Versioned')).toEqual(['calls lib/log/v2/log.go:Infof']);
+  });
+
+  it('leaves a file importing the standard library package alone', () => {
+    expect(edgesFrom('svc/std.go', 'Std')).toEqual([]);
+  });
+
+  it('leaves a variable of that name alone when the file imports no such package', () => {
+    const edges = edgesFrom('svc/variable.go', 'Variable');
+    expect(edges).not.toContain('calls lib/errors/errors.go:New');
+  });
+});
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index 7c16dbd13..44ab24ba5 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -2776,6 +2776,16 @@ export class ReferenceResolver {
     return false;
   }
 
+  /**
+   * True when the Go file imports `qualifier` — by its last path segment or
+   * an alias — from a package of one of the project's own modules.
+   */
+  private isGoProjectPackage(ref: UnresolvedRef, qualifier: string): boolean {
+    return this.context
+      .getImportMappings(ref.filePath, ref.language)
+      .some((imp) => imp.localName === qualifier && this.context.getGoPackageDir?.(imp.source, ref.filePath) != null);
+  }
+
   /**
    * Check if reference is to a built-in or external symbol
    */
@@ -2870,7 +2880,9 @@ export class ReferenceResolver {
     // Go standard library packages — refs like "fmt.Println", "http.ListenAndServe", etc.
     if (ref.language === 'go') {
       const dotIdx = name.indexOf('.');
-      if (dotIdx > 0) {
+      // What the file imports decides before the name does: a project package
+      // may be called `errors`, `log` or `types` too.
+      if (dotIdx > 0 && !this.isGoProjectPackage(ref, name.substring(0, dotIdx))) {
         const pkg = name.substring(0, dotIdx);
         // Not a local bound from a type assertion that is named like one:
         // grpc-go's `parser.ParseConfig(…)` after `parser, ok :=