diff --git a/tooling/antd-codemods/README.md b/tooling/antd-codemods/README.md
index 02b51a6d34a1..c3c23311f8f3 100644
--- a/tooling/antd-codemods/README.md
+++ b/tooling/antd-codemods/README.md
@@ -33,6 +33,127 @@ a `CoreTypography`-aliased import alongside the surviving antd one. The
 `Typography.Title` `level` → `size` convention (`LEVEL_SIZE_MAP` in the
 transform) was approved 2026-07-30.
 
+## `antd-button-to-core.js`
+
+In any file that imports `Button` from `'antd'` (single or double quotes;
+sibling named imports like `import { Button, Modal } from 'antd'` are
+preserved), and/or imports the legacy default `ButtonGroup` from the antd
+subpath (`antd/es/button/button-group` or `antd/lib/button/button-group`).
+Mapping rules approved 2026-07-30 — see
+`.context/wave1-prep/button-gap-check.md` and the mapping guide
+(`docs/antd-migration/button.md`) for the full survey data behind them.
+
+| antd | Core | Notes |
+|---|---|---|
+| `type="primary"` | `color="primary"` | direct |
+| `type="default"` | `color="secondary"` | direct |
+| `type="text"` | `color="tertiary"` | direct |
+| `type="link"` | `color="link-gray"` | direct |
+| no `type` prop at all | `color="secondary"` | antd's implicit default type is `"default"`, which maps to `secondary` — core's own default is `"primary"`, so this must be made explicit rather than omitted |
+| `danger` + a base type | folds into `color`: `primary`→`primary-destructive`, `default`→`secondary-destructive`, `text`→`tertiary-destructive`, `link`→`link-destructive` | not a rename — `danger` is dropped, `type` is dropped, `color` carries both |
+| bare `danger` (no `type`) | `color="secondary-destructive"` | antd's implicit default type is `"default"` |
+| `ghost` (boolean) or `type="ghost"` | `color="tertiary"` | approved 2026-07-30; **always reported via a `converted-with-warnings -> ghost-remap` console.warn** even though the element still converts, so sweep reviewers eyeball every site |
+| `size="small"` / `"middle"` / `"large"` | `size="xs"` / `"sm"` / `"md"` | approved 2026-07-30 |
+| `size={expr}` (dynamic) | — | skipped, see below |
+| `disabled` (bare or `={expr}`) | `isDisabled` | rename, same form |
+| `loading` (bare or `={expr}`) | `isLoading` | rename, same form |
+| `loading={{ delay }}` (object) | — | skipped, see below |
+| `icon={...}` (any value form) | `iconLeading={...}` | rename |
+| `htmlType="X"` | native `type="X"` | processed **after** the visual `type`→`color` rewrite on the same element so the two never collide (core's `type` is the native HTML type, the inverse of antd's meaning) |
+| `block` | merged into `className` as `tw:w-full` (creates `className` if absent) | needs visual QA per the mapping guide |
+| `shape="circle"` / `"round"` | — | skipped, see below |
+| `Button.Group` | — | skipped, see below |
+| `ButtonGroup` (subpath import) | — | skipped, see below; the subpath import itself is never touched |
+| `ref={...}` | unchanged | kept as-is — core `Button` is `forwardRef`-wrapped |
+| `href` / `target` / `onClick` / `className` / `data-testid` / `style` / `autoFocus` / `title` | unchanged | native passthrough |
+
+### Deliberate skips (left as antd, reported via `console.warn`)
+
+Same convention as the Typography transform: when an element is skipped,
+the **whole element** is left completely untouched — still antd — and a
+single line is printed per file listing every skip, e.g.:
+
+    [antd-button-to-core] src/components/Foo.tsx: needs hand-finish -> Button(shape-unsupported), Button.Group(button-group)
+
+Skip categories:
+
+- **`shape="circle"` / `shape="round"`** — `shape-unsupported`. Core's
+  icon-only auto-detection gives a rounded square, never a true circle or
+  pill — no mechanical equivalent for either value.
+- **`type={expr}`** (dynamic, non-literal) — `dynamic-type`.
+- **`type="..."` with a value outside `primary`/`default`/`text`/`link`/`ghost`**
+  (e.g. the unused `dashed`) — `unsupported-type`.
+- **`ghost={expr}`** where `expr` isn't a literal boolean — `dynamic-ghost`.
+- **`danger={expr}`** where `expr` isn't a literal boolean —
+  `dynamic-danger`.
+- **`size={expr}`** (dynamic, non-literal) — `dynamic-size`. 48 combined
+  occurrences across repos per the gap-check survey — the single largest
+  hand-finish category.
+- **`size="..."` with a value outside `small`/`middle`/`large`** —
+  `unsupported-size`.
+- **`loading={{ delay }}`** (object/debounce form) — `loading-object`.
+  Unused in practice, but no core equivalent, so hand-finish rather than
+  guess.
+- **`block` combined with a non-literal `className`** (e.g.
+  `className={someVar}`) — `dynamic-classname`. The transform can only
+  safely merge `tw:w-full` into a string literal.
+- **`Button.Group`** (member expression off the antd `Button` import) —
+  `button-group`. Core `ButtonGroup` is a single-select toggle group;
+  antd's legacy usage groups independent action buttons — semantic
+  mismatch, redesign per site as a flex row of `Button`s.
+- **`ButtonGroup` from the `antd/{es,lib}/button/button-group` subpath
+  default import** — `button-group-subpath`. Reported the same way; the
+  subpath import declaration itself is never modified, only warned about.
+
+A **`ghost`/`type="ghost"` element is not a skip** — it converts to
+`color="tertiary"` and is separately flagged via a
+`converted-with-warnings -> ghost-remap` warning, distinct from the
+hand-finish skip line, since the mapping is approved and mechanical but
+still worth a reviewer's eyes per site.
+
+### Partial-conversion files
+
+If a file has at least one skipped `Button`/`Button.Group` element, the
+antd `Button` import **stays**, and the transform adds a second import
+aliasing the core component to avoid a name collision:
+
+    import { Button } from 'antd';
+    import { Button as CoreButton } from '@openmetadata/ui-core-components';
+
+Converted elements in that file use `<CoreButton>`; skipped elements keep
+using `<Button>` (antd). Only when **every** `Button`/`Button.Group` usage
+in the file converts does the transform remove `Button` from the antd
+import (dropping the import entirely if it becomes empty, or merging into
+an existing `@openmetadata/ui-core-components` import if one is already
+present) and emit plain `<Button>` / `import { Button } from
+'@openmetadata/ui-core-components'`.
+
+Skipped `ButtonGroup`-subpath elements do **not** affect this decision —
+that subpath import is entirely independent of the antd `Button` import
+and is never touched either way.
+
+Leading file comments (license headers) are preserved when the antd import
+is fully removed, following the same comment re-homing logic as
+`move-named-imports.js`.
+
+### Known limitations / follow-ups
+
+- `icon={<Icon component={Svg} />}` is renamed to `iconLeading={<Icon
+  component={Svg} />}` verbatim — the transform does **not** unwrap the
+  antd `Icon`/`component` wrapper down to the bare `Svg`, even though core
+  accepts the bare `FC<{className}>` form directly. Left as a manual
+  simplification per the mapping guide.
+- `shape="circle"`/`"round"`, `Button.Group`, and the `ButtonGroup` subpath
+  are permanent gaps (no mechanical core equivalent), not pending
+  ui-core-components work — see the mapping guide's "No direct
+  equivalent" table for the by-hand replacement pattern for each.
+- Border-override `className` drift (any carried-over class targeting
+  border/shadow/ring color) is **not** detected or rewritten by this
+  transform — per the mapping guide, those must be re-pointed at
+  `tw:after:outline-*` by hand during the sweep review, since a
+  `tw:ring-*`/`tw:outline-*` string is indistinguishable from any other
+  className token at the AST level.
+
 ## Tests
 
     yarn test
diff --git a/tooling/antd-codemods/__tests__/antd-button-to-core.test.js b/tooling/antd-codemods/__tests__/antd-button-to-core.test.js
new file mode 100644
index 000000000000..fa4750fb7087
--- /dev/null
+++ b/tooling/antd-codemods/__tests__/antd-button-to-core.test.js
@@ -0,0 +1,447 @@
+'use strict';
+const { defineInlineTest } = require('jscodeshift/dist/testUtils');
+const transform = require('../transforms/antd-button-to-core');
+
+const OPTS = {};
+
+// -- `type` literal mapping (incl. no-type -> secondary default) --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button type="primary">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='primary'>Click</Button>;`,
+  'type="primary" becomes color="primary"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button type="default">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary'>Click</Button>;`,
+  'type="default" becomes color="secondary"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button type="text">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='tertiary'>Click</Button>;`,
+  'type="text" becomes color="tertiary"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button type="link">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='link-gray'>Click</Button>;`,
+  'type="link" becomes color="link-gray"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button onClick={fn}>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button onClick={fn} color='secondary'>Click</Button>;`,
+  'no `type` prop: antd default type is "default" -> explicit color="secondary" (core default is "primary")'
+);
+
+// -- `danger` fold-in, per base type, plus bare danger --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button danger type="primary">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='primary-destructive'>Click</Button>;`,
+  'danger + type="primary" -> color="primary-destructive"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button danger type="default">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary-destructive'>Click</Button>;`,
+  'danger + type="default" -> color="secondary-destructive"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button danger type="text">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='tertiary-destructive'>Click</Button>;`,
+  'danger + type="text" -> color="tertiary-destructive"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button danger type="link">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='link-destructive'>Click</Button>;`,
+  'danger + type="link" -> color="link-destructive"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button danger onClick={fn}>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button onClick={fn} color='secondary-destructive'>Click</Button>;`,
+  'bare `danger` (no type): antd default type is "default" -> color="secondary-destructive"'
+);
+
+// -- `ghost` boolean and `type="ghost"` literal --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button ghost onClick={fn}>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button onClick={fn} color='tertiary'>Click</Button>;`,
+  '`ghost` boolean modifier -> color="tertiary" (approved 2026-07-30), reported via ghost-remap warn'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button type="ghost">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='tertiary'>Click</Button>;`,
+  'type="ghost" literal -> color="tertiary" (same mapping as boolean ghost)'
+);
+
+// -- `size` literal mapping + dynamic-size skip --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button size="small">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' size='xs'>Click</Button>;`,
+  'size="small" -> size="xs"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button size="middle">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' size='sm'>Click</Button>;`,
+  'size="middle" -> size="sm"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button size="large">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' size='md'>Click</Button>;`,
+  'size="large" -> size="md"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = ({ sz }) => <Button size={sz}>Click</Button>;`,
+  `import { Button } from 'antd';\nconst App = ({ sz }) => <Button size={sz}>Click</Button>;`,
+  'size={dynamicExpr}: left untouched, reported as needs-hand-finish (dynamic-size)'
+);
+
+// -- `disabled` / `loading` renames, both bare and ={expr} forms --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button disabled>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' isDisabled>Click</Button>;`,
+  'bare `disabled` -> bare `isDisabled`'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button disabled={isBlocked}>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' isDisabled={isBlocked}>Click</Button>;`,
+  '`disabled={expr}` -> `isDisabled={expr}`'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button loading>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' isLoading>Click</Button>;`,
+  'bare `loading` -> bare `isLoading`'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button loading={isSaving}>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' isLoading={isSaving}>Click</Button>;`,
+  '`loading={expr}` -> `isLoading={expr}`'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button loading={{ delay: 200 }}>Click</Button>;`,
+  `import { Button } from 'antd';\nconst App = () => <Button loading={{ delay: 200 }}>Click</Button>;`,
+  '`loading={{ delay }}` object form: left untouched, reported (loading-object)'
+);
+
+// -- `htmlType` + `type` on the same element (ordering) --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button htmlType="submit" type="primary">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='primary' type='submit'>Click</Button>;`,
+  '`htmlType` + `type` on the same element: never collide, both rewritten correctly'
+);
+
+// -- `icon` rename --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button icon={<PlusOutlined />}>Add</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' iconLeading={<PlusOutlined />}>Add</Button>;`,
+  '`icon={...}` -> `iconLeading={...}` (any value form)'
+);
+
+// -- `block` into existing/absent className + dynamic-className skip --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button block>Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' className='tw:w-full'>Click</Button>;`,
+  '`block` with no className: creates className="tw:w-full"'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button block className="existing-class">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='secondary' className='existing-class tw:w-full'>Click</Button>;`,
+  '`block` with an existing literal className: merges tw:w-full'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button block className={dynamicClass}>Click</Button>;`,
+  `import { Button } from 'antd';\nconst App = () => <Button block className={dynamicClass}>Click</Button>;`,
+  '`block` with a non-literal className: left untouched, reported (dynamic-classname)'
+);
+
+// -- `shape` skips --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button shape="circle">X</Button>;`,
+  `import { Button } from 'antd';\nconst App = () => <Button shape="circle">X</Button>;`,
+  'shape="circle": left untouched, reported (shape-unsupported)'
+);
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button shape="round">X</Button>;`,
+  `import { Button } from 'antd';\nconst App = () => <Button shape="round">X</Button>;`,
+  'shape="round": left untouched, reported (shape-unsupported)'
+);
+
+// -- `Button.Group` skip --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button.Group>Hi</Button.Group>;`,
+  `import { Button } from 'antd';\nconst App = () => <Button.Group>Hi</Button.Group>;`,
+  '`Button.Group`: left untouched entirely, reported (button-group)'
+);
+
+// -- `ButtonGroup`-from-subpath skip --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import ButtonGroup from 'antd/lib/button/button-group';\nconst App = () => <ButtonGroup>Hi</ButtonGroup>;`,
+  `import ButtonGroup from 'antd/lib/button/button-group';\nconst App = () => <ButtonGroup>Hi</ButtonGroup>;`,
+  '`ButtonGroup` from the antd subpath import: left untouched, reported (button-group-subpath), import untouched'
+);
+
+// -- `ref` preserved (forwardRef landed, no skip) --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => <Button ref={btnRef} type="primary">Click</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button ref={btnRef} color='primary'>Click</Button>;`,
+  '`ref={...}` is kept as-is (Button is forwardRef-wrapped) and the element still converts'
+);
+
+// -- Partial conversion: CoreButton alias, both imports kept --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from 'antd';\nconst App = () => (\n  <>\n    <Button type="primary">Ok</Button>\n    <Button shape="circle">X</Button>\n  </>\n);`,
+  `import { Button } from 'antd';\nimport { Button as CoreButton } from '@openmetadata/ui-core-components';\nconst App = () => (\n  <>\n    <CoreButton color='primary'>Ok</CoreButton>\n    <Button shape="circle">X</Button>\n  </>\n);`,
+  'partial conversion: one skip forces the CoreButton alias, antd Button import stays for the skipped element'
+);
+
+// -- Full conversion: import swap + license header preserved --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `/*\n * License header\n */\nimport { Button } from 'antd';\nconst App = () => <Button type="primary">Ok</Button>;`,
+  `/*\n * License header\n */\nimport { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='primary'>Ok</Button>;`,
+  'preserves a license header comment when the antd import is fully removed'
+);
+
+// -- Double-quote imports --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button } from "antd";\nconst App = () => <Button type="primary">Ok</Button>;`,
+  `import { Button } from '@openmetadata/ui-core-components';\nconst App = () => <Button color='primary'>Ok</Button>;`,
+  'double-quoted antd import is matched the same as single-quoted'
+);
+
+// -- Multi-specifier antd import keeps siblings --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Button, Modal } from 'antd';\nconst App = () => (\n  <>\n    <Modal />\n    <Button type="primary">Ok</Button>\n  </>\n);`,
+  `import { Modal } from 'antd';\nimport { Button } from '@openmetadata/ui-core-components';\nconst App = () => (\n  <>\n    <Modal />\n    <Button color='primary'>Ok</Button>\n  </>\n);`,
+  'multi-specifier antd import keeps sibling specifiers (Modal) on antd'
+);
+
+// -- Merges into an existing core import when fully converted --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Card } from '@openmetadata/ui-core-components';\nimport { Button } from 'antd';\nconst App = () => (\n  <>\n    <Card />\n    <Button type="primary">Ok</Button>\n  </>\n);`,
+  `import { Card, Button } from '@openmetadata/ui-core-components';\nconst App = () => (\n  <>\n    <Card />\n    <Button color='primary'>Ok</Button>\n  </>\n);`,
+  'merges into an existing core import when fully converted'
+);
+
+// -- No-op when the file doesn't import Button from antd at all --
+
+defineInlineTest(
+  transform,
+  OPTS,
+  `import { Modal } from 'antd';\nconst App = () => <Modal />;`,
+  `import { Modal } from 'antd';\nconst App = () => <Modal />;`,
+  'no-op when the file does not import Button from antd (or the subpath) at all'
+);
+
+describe('console.warn reporting', () => {
+  let warnSpy;
+
+  beforeEach(() => {
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it('warns with the file path and skip reason for a dynamic size', () => {
+    transform(
+      {
+        path: 'src/components/Foo.tsx',
+        source: `import { Button } from 'antd';\nconst App = ({ sz }) => <Button size={sz}>Click</Button>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('src/components/Foo.tsx');
+    expect(message).toContain('dynamic-size');
+  });
+
+  it('warns for the loading={{ delay }} object form', () => {
+    transform(
+      {
+        path: 'src/components/Bar.tsx',
+        source: `import { Button } from 'antd';\nconst App = () => <Button loading={{ delay: 200 }}>Click</Button>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('loading-object');
+  });
+
+  it('warns for shape-unsupported', () => {
+    transform(
+      {
+        path: 'src/components/Baz.tsx',
+        source: `import { Button } from 'antd';\nconst App = () => <Button shape="round">X</Button>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('shape-unsupported');
+  });
+
+  it('warns for Button.Group', () => {
+    transform(
+      {
+        path: 'src/components/Qux.tsx',
+        source: `import { Button } from 'antd';\nconst App = () => <Button.Group>Hi</Button.Group>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('button-group');
+  });
+
+  it('warns for the ButtonGroup subpath import without touching it', () => {
+    transform(
+      {
+        path: 'src/components/Quux.tsx',
+        source: `import ButtonGroup from 'antd/lib/button/button-group';\nconst App = () => <ButtonGroup>Hi</ButtonGroup>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('button-group-subpath');
+  });
+
+  it('warns with ghost-remap for a converted (not skipped) ghost element', () => {
+    transform(
+      {
+        path: 'src/components/Ghost.tsx',
+        source: `import { Button } from 'antd';\nconst App = () => <Button ghost>Click</Button>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const [message] = warnSpy.mock.calls[0];
+    expect(message).toContain('converted-with-warnings');
+    expect(message).toContain('ghost-remap');
+  });
+
+  it('does not warn when everything converts cleanly', () => {
+    transform(
+      {
+        path: 'src/components/Clean.tsx',
+        source: `import { Button } from 'antd';\nconst App = () => <Button type="primary">Ok</Button>;`,
+      },
+      { jscodeshift: require('jscodeshift').withParser('tsx') }
+    );
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});
diff --git a/tooling/antd-codemods/transforms/antd-button-to-core.js b/tooling/antd-codemods/transforms/antd-button-to-core.js
new file mode 100644
index 000000000000..6cc115dfcccc
--- /dev/null
+++ b/tooling/antd-codemods/transforms/antd-button-to-core.js
@@ -0,0 +1,478 @@
+'use strict';
+
+/**
+ * Converts antd `Button` (and flags `Button.Group` / the
+ * `antd/{es,lib}/button/button-group` subpath) to the core `Button` from
+ * `@openmetadata/ui-core-components`.
+ *
+ * jscodeshift -t transforms/antd-button-to-core.js <path> --parser=tsx
+ *
+ * See README.md for the full mapping table and the list of constructs this
+ * transform deliberately leaves untouched for hand-finishing. Mirrors the
+ * structure and conventions of transforms/antd-typography-to-core.js.
+ */
+
+const CORE_MODULE = '@openmetadata/ui-core-components';
+const ANTD_MODULE = 'antd';
+const CORE_LOCAL_ALIAS = 'CoreButton';
+
+// Approved 2026-07-30 (see docs/antd-migration/button.md).
+const SIZE_MAP = { small: 'xs', middle: 'sm', large: 'md' };
+
+// antd `type` (visual variant) -> core `color`, non-destructive.
+const BASE_COLOR_MAP = {
+  primary: 'primary',
+  default: 'secondary',
+  text: 'tertiary',
+  link: 'link-gray',
+};
+
+// antd `type` + `danger` -> core `color`, destructive variant.
+const DESTRUCTIVE_COLOR_MAP = {
+  primary: 'primary-destructive',
+  default: 'secondary-destructive',
+  text: 'tertiary-destructive',
+  link: 'link-destructive',
+};
+
+const SUBPATH_IMPORT_RE = /^antd\/(?:es|lib)\/button\/button-group$/;
+
+// Reads the resolved literal value of a JSX attribute, distinguishing a
+// present-but-dynamic value from a present-and-literal one so callers can
+// tell "safe to convert" apart from "must skip and hand-finish".
+function readAttrLiteral(attr) {
+  if (!attr) {
+    return { present: false };
+  }
+  if (attr.value == null) {
+    // `<Button danger />` — implicit `true`.
+    return { present: true, isLiteral: true, value: true };
+  }
+  if (attr.value.type === 'StringLiteral' || attr.value.type === 'Literal') {
+    return { present: true, isLiteral: true, value: attr.value.value };
+  }
+  if (attr.value.type === 'JSXExpressionContainer') {
+    const expr = attr.value.expression;
+    if (
+      expr.type === 'NumericLiteral' ||
+      expr.type === 'BooleanLiteral' ||
+      expr.type === 'StringLiteral' ||
+      expr.type === 'Literal'
+    ) {
+      return { present: true, isLiteral: true, value: expr.value };
+    }
+    return { present: true, isLiteral: false, expression: expr };
+  }
+  return { present: true, isLiteral: false };
+}
+
+function findAttr(attributes, name) {
+  return attributes.find(
+    (attr) => attr.type === 'JSXAttribute' && attr.name.name === name
+  );
+}
+
+module.exports = function transformer(file, api) {
+  const j = api.jscodeshift;
+  const filePath = (file && file.path) || '<unknown>';
+  const root = j(typeof file === 'string' ? file : file.source);
+
+  // -- Locate the antd `Button` named import (if any). --
+  let buttonLocalName = null;
+  let buttonImportPath = null;
+  root
+    .find(j.ImportDeclaration, { source: { value: ANTD_MODULE } })
+    .forEach((path) => {
+      path.node.specifiers.forEach((spec) => {
+        if (spec.type === 'ImportSpecifier' && spec.imported.name === 'Button') {
+          buttonLocalName = spec.local.name;
+          buttonImportPath = path;
+        }
+      });
+    });
+
+  // -- Locate the legacy `antd/{es,lib}/button/button-group` subpath default
+  // import (if any). Never touched beyond warning when its elements skip. --
+  let subpathLocalName = null;
+  root.find(j.ImportDeclaration).forEach((path) => {
+    if (typeof path.node.source.value !== 'string') {
+      return;
+    }
+    if (!SUBPATH_IMPORT_RE.test(path.node.source.value)) {
+      return;
+    }
+    path.node.specifiers.forEach((spec) => {
+      if (spec.type === 'ImportDefaultSpecifier' && spec.local) {
+        subpathLocalName = spec.local.name;
+      }
+    });
+  });
+
+  if (!buttonLocalName && !subpathLocalName) {
+    return file.source;
+  }
+
+  function classifyElement(node) {
+    const name = node.openingElement.name;
+    if (
+      buttonLocalName &&
+      name.type === 'JSXMemberExpression' &&
+      name.object.type === 'JSXIdentifier' &&
+      name.object.name === buttonLocalName
+    ) {
+      if (name.property.name === 'Group') {
+        return { kind: 'ButtonGroup', matchType: 'member-group' };
+      }
+      return null;
+    }
+    if (name.type === 'JSXIdentifier') {
+      if (buttonLocalName && name.name === buttonLocalName) {
+        return { kind: 'Button', matchType: 'direct' };
+      }
+      if (subpathLocalName && name.name === subpathLocalName) {
+        return { kind: 'ButtonGroupSubpath', matchType: 'subpath' };
+      }
+    }
+    return null;
+  }
+
+  function renameAttr(attr, newName) {
+    if (attr.value == null) {
+      return j.jsxAttribute(j.jsxIdentifier(newName));
+    }
+    // Rebuild string-literal values fresh so recast re-emits them with the
+    // configured quote style, rather than reusing the original (possibly
+    // double-quoted) node verbatim.
+    if (attr.value.type === 'StringLiteral' || attr.value.type === 'Literal') {
+      return j.jsxAttribute(j.jsxIdentifier(newName), j.stringLiteral(attr.value.value));
+    }
+    return j.jsxAttribute(j.jsxIdentifier(newName), attr.value);
+  }
+
+  // Attempts to convert a single `<Button>` element in place. Returns
+  // `{ skip: false, warnings: [...] }` on success (attributes already
+  // rewritten) or `{ skip: true, reason }` if the element must stay
+  // untouched.
+  function convertElement(elNode) {
+    const opening = elNode.openingElement;
+    const attrs = opening.attributes;
+
+    // No core equivalent for any `shape` value in current usage
+    // (circle/round) — always hand-finish.
+    if (findAttr(attrs, 'shape')) {
+      return { skip: true, reason: 'shape-unsupported' };
+    }
+
+    const ghostAttr = findAttr(attrs, 'ghost');
+    let ghostApplies = false;
+    if (ghostAttr) {
+      const lit = readAttrLiteral(ghostAttr);
+      if (!lit.isLiteral || typeof lit.value !== 'boolean') {
+        return { skip: true, reason: 'dynamic-ghost' };
+      }
+      ghostApplies = lit.value === true;
+    }
+
+    const typeAttr = findAttr(attrs, 'type');
+    let typeValue = null;
+    if (typeAttr) {
+      const lit = readAttrLiteral(typeAttr);
+      if (!lit.isLiteral || typeof lit.value !== 'string') {
+        return { skip: true, reason: 'dynamic-type' };
+      }
+      if (lit.value === 'ghost') {
+        ghostApplies = true;
+      } else if (!BASE_COLOR_MAP[lit.value]) {
+        return { skip: true, reason: 'unsupported-type' };
+      } else {
+        typeValue = lit.value;
+      }
+    }
+
+    const dangerAttr = findAttr(attrs, 'danger');
+    let dangerApplies = false;
+    if (dangerAttr) {
+      const lit = readAttrLiteral(dangerAttr);
+      if (!lit.isLiteral || typeof lit.value !== 'boolean') {
+        return { skip: true, reason: 'dynamic-danger' };
+      }
+      dangerApplies = lit.value === true;
+    }
+
+    const sizeAttr = findAttr(attrs, 'size');
+    let sizeValue = null;
+    if (sizeAttr) {
+      const lit = readAttrLiteral(sizeAttr);
+      if (!lit.isLiteral || typeof lit.value !== 'string') {
+        return { skip: true, reason: 'dynamic-size' };
+      }
+      if (!SIZE_MAP[lit.value]) {
+        return { skip: true, reason: 'unsupported-size' };
+      }
+      sizeValue = SIZE_MAP[lit.value];
+    }
+
+    const loadingAttr = findAttr(attrs, 'loading');
+    if (
+      loadingAttr &&
+      loadingAttr.value &&
+      loadingAttr.value.type === 'JSXExpressionContainer' &&
+      loadingAttr.value.expression.type === 'ObjectExpression'
+    ) {
+      // `loading={{ delay }}` debounce form — unused in practice, but no
+      // core equivalent, so hand-finish rather than guess.
+      return { skip: true, reason: 'loading-object' };
+    }
+
+    const blockAttr = findAttr(attrs, 'block');
+    const classNameAttr = findAttr(attrs, 'className');
+    if (blockAttr && classNameAttr) {
+      const isPlainString =
+        classNameAttr.value &&
+        (classNameAttr.value.type === 'StringLiteral' ||
+          classNameAttr.value.type === 'Literal');
+      if (!isPlainString) {
+        return { skip: true, reason: 'dynamic-classname' };
+      }
+    }
+
+    // -- All checks passed — compute the resolved `color`. --
+    const warnings = [];
+    let color;
+    if (ghostApplies) {
+      color = 'tertiary';
+      warnings.push('ghost-remap');
+    } else {
+      const baseType = typeValue || 'default';
+      color = dangerApplies
+        ? DESTRUCTIVE_COLOR_MAP[baseType]
+        : BASE_COLOR_MAP[baseType];
+    }
+
+    const disabledAttr = findAttr(attrs, 'disabled');
+    const htmlTypeAttr = findAttr(attrs, 'htmlType');
+    const iconAttr = findAttr(attrs, 'icon');
+
+    const EXCLUDE = new Set([
+      'type',
+      'danger',
+      'ghost',
+      'size',
+      'disabled',
+      'loading',
+      'htmlType',
+      'icon',
+      'block',
+    ]);
+    if (blockAttr) {
+      EXCLUDE.add('className');
+    }
+
+    const newAttrs = [];
+    attrs.forEach((attr) => {
+      if (attr.type !== 'JSXAttribute') {
+        newAttrs.push(attr); // JSXSpreadAttribute — pass through
+        return;
+      }
+      if (EXCLUDE.has(attr.name.name)) {
+        return; // handled below
+      }
+      newAttrs.push(attr);
+    });
+
+    newAttrs.push(j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral(color)));
+    if (sizeValue) {
+      newAttrs.push(j.jsxAttribute(j.jsxIdentifier('size'), j.stringLiteral(sizeValue)));
+    }
+    if (disabledAttr) {
+      newAttrs.push(renameAttr(disabledAttr, 'isDisabled'));
+    }
+    if (loadingAttr) {
+      newAttrs.push(renameAttr(loadingAttr, 'isLoading'));
+    }
+    if (iconAttr) {
+      newAttrs.push(renameAttr(iconAttr, 'iconLeading'));
+    }
+    // `htmlType` -> native `type`, processed *after* the visual `type` ->
+    // `color` rewrite above so the two never collide on the same prop name.
+    if (htmlTypeAttr) {
+      newAttrs.push(renameAttr(htmlTypeAttr, 'type'));
+    }
+    if (blockAttr) {
+      if (classNameAttr) {
+        const merged = `${classNameAttr.value.value} tw:w-full`.trim();
+        newAttrs.push(
+          j.jsxAttribute(j.jsxIdentifier('className'), j.stringLiteral(merged))
+        );
+      } else {
+        newAttrs.push(
+          j.jsxAttribute(j.jsxIdentifier('className'), j.stringLiteral('tw:w-full'))
+        );
+      }
+    }
+
+    opening.attributes = newAttrs;
+    return { skip: false, warnings };
+  }
+
+  const buttonSkips = []; // ties up the antd Button import; forces partial conversion
+  const subpathSkips = []; // unrelated import; warn-only
+  const conversionWarnings = [];
+  const convertedElements = [];
+
+  root.find(j.JSXElement).forEach((elPath) => {
+    const classification = classifyElement(elPath.node);
+    if (!classification) {
+      return;
+    }
+    if (classification.kind === 'ButtonGroup') {
+      buttonSkips.push({ kind: 'Button.Group', reason: 'button-group' });
+      return;
+    }
+    if (classification.kind === 'ButtonGroupSubpath') {
+      subpathSkips.push({ kind: 'ButtonGroup', reason: 'button-group-subpath' });
+      return;
+    }
+    const result = convertElement(elPath.node);
+    if (result.skip) {
+      buttonSkips.push({ kind: 'Button', reason: result.reason });
+      return;
+    }
+    convertedElements.push(elPath.node);
+    result.warnings.forEach((reason) => conversionWarnings.push(reason));
+  });
+
+  if (buttonSkips.length || subpathSkips.length) {
+    const summary = [...buttonSkips, ...subpathSkips]
+      .map((s) => `${s.kind}(${s.reason})`)
+      .join(', ');
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[antd-button-to-core] ${filePath}: needs hand-finish -> ${summary}`
+    );
+  }
+
+  if (conversionWarnings.length) {
+    const summary = conversionWarnings.join(', ');
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[antd-button-to-core] ${filePath}: converted-with-warnings -> ${summary}`
+    );
+  }
+
+  if (!convertedElements.length) {
+    return file.source;
+  }
+
+  const fullyConvertedFile = buttonSkips.length === 0;
+  const finalCoreName = fullyConvertedFile ? 'Button' : CORE_LOCAL_ALIAS;
+
+  convertedElements.forEach((node) => {
+    node.openingElement.name = j.jsxIdentifier(finalCoreName);
+    if (node.closingElement) {
+      node.closingElement.name = j.jsxIdentifier(finalCoreName);
+    }
+  });
+
+  const coreImports = root.find(j.ImportDeclaration, {
+    source: { value: CORE_MODULE },
+  });
+
+  function replaceImportPreservingHeader(path, newDecl) {
+    newDecl.comments = path.node.comments;
+    j(path).replaceWith(newDecl);
+  }
+
+  function removeImportPreservingHeader(path) {
+    const wasFirstStatement = root.get().node.program.body[0] === path.node;
+    const leadingComments = path.node.comments;
+    j(path).remove();
+    if (wasFirstStatement && leadingComments && leadingComments.length) {
+      const [firstStatement] = root.get().node.program.body;
+      if (firstStatement) {
+        firstStatement.comments = [
+          ...leadingComments,
+          ...(firstStatement.comments || []),
+        ];
+      }
+    }
+  }
+
+  if (fullyConvertedFile) {
+    const remainingSpecifiers = buttonImportPath.node.specifiers.filter(
+      (spec) => !(spec.type === 'ImportSpecifier' && spec.imported.name === 'Button')
+    );
+
+    const hasCoreButtonAlready = coreImports
+      .nodes()
+      .some((n) =>
+        n.specifiers.some(
+          (s) =>
+            s.type === 'ImportSpecifier' &&
+            s.imported.name === 'Button' &&
+            s.local.name === 'Button'
+        )
+      );
+
+    if (remainingSpecifiers.length) {
+      buttonImportPath.node.specifiers = remainingSpecifiers;
+      if (!hasCoreButtonAlready) {
+        if (coreImports.size()) {
+          coreImports.at(0).get().node.specifiers.push(
+            j.importSpecifier(j.identifier('Button'))
+          );
+        } else {
+          const decl = j.importDeclaration(
+            [j.importSpecifier(j.identifier('Button'))],
+            j.literal(CORE_MODULE)
+          );
+          j(buttonImportPath).insertAfter(decl);
+        }
+      }
+    } else if (!hasCoreButtonAlready && !coreImports.size()) {
+      const decl = j.importDeclaration(
+        [j.importSpecifier(j.identifier('Button'))],
+        j.literal(CORE_MODULE)
+      );
+      replaceImportPreservingHeader(buttonImportPath, decl);
+    } else {
+      removeImportPreservingHeader(buttonImportPath);
+      if (!hasCoreButtonAlready) {
+        coreImports.at(0).get().node.specifiers.push(
+          j.importSpecifier(j.identifier('Button'))
+        );
+      }
+    }
+  } else {
+    const hasAlias = coreImports
+      .nodes()
+      .some((n) =>
+        n.specifiers.some(
+          (s) =>
+            s.type === 'ImportSpecifier' &&
+            s.imported.name === 'Button' &&
+            s.local.name === CORE_LOCAL_ALIAS
+        )
+      );
+    if (!hasAlias) {
+      if (coreImports.size()) {
+        coreImports.at(0).get().node.specifiers.push(
+          j.importSpecifier(j.identifier('Button'), j.identifier(CORE_LOCAL_ALIAS))
+        );
+      } else {
+        const decl = j.importDeclaration(
+          [j.importSpecifier(j.identifier('Button'), j.identifier(CORE_LOCAL_ALIAS))],
+          j.literal(CORE_MODULE)
+        );
+        j(buttonImportPath).insertAfter(decl);
+      }
+    }
+  }
+
+  return root.toSource({ quote: 'single' });
+};
+
+module.exports.parser = 'tsx';
+module.exports.SIZE_MAP = SIZE_MAP;
+module.exports.BASE_COLOR_MAP = BASE_COLOR_MAP;
+module.exports.DESTRUCTIVE_COLOR_MAP = DESTRUCTIVE_COLOR_MAP;