Merge branch 'main' into fix/incident-comment-feed-33112

Resolves one conflict in playwright/eslint-rules/tests/corpus.test.mjs.
Both sides lowered the recorded no-positional-locator total from 1298:
this branch to 1291 (the TaskComments.spec.ts burn-down of 7) and main to
1243 (55 from other burn-downs). Neither side alone is right, so take the
combined total of 1236, which is what the merged eslint-suppressions.json
actually sums to.

Author: Vansh0310

.claude/rules/frontend-permissions.md

@@ -0,0 +1,93 @@
+---
+description: How UI code reads permissions — the useEntityPermissions hook, derived flags, and the ban on raw permission-key reads
+paths: "openmetadata-ui/src/main/resources/ui/**/*.{ts,tsx}"
+---
+
+# Frontend permissions
+
+Applies to UI `*.{ts,tsx}`. Concept, full flag table and rationale:
+`openmetadata-ui/src/main/resources/ui/docs/permissions.md`.
+
+**One rule: never read a permission key directly. Ask for the intent.**
+
+```ts
+// ✗ banned — `openmetadata-permissions/no-raw-permission-access` fails the build
+if (permissions.EditAll || permissions.EditDescription) { … }
+
+// ✓ derived flag
+const { canEditDescription } = useEntityPermissions(ResourceEntity.TABLE, fqn);
+```
+
+The rule guards `EditAll`, `ViewAll` and `ViewBasic` at **error**. Other keys are unguarded but
+the same rule applies — use the flag.
+
+## Fetching
+
+```ts
+const {
+  canEditTags, hasViewAccess, /* …flags */
+  permissions,      // raw OperationPermission, for props that still require it
+  isLoading, error, refresh,
+} = useEntityPermissions(resource, identifier, options);
+```
+
+- `identifier` — an **fqn string**, or `{ id }` to look up by id.
+- `options` — `{ deleted?: boolean; enabled?: boolean }`; `enabled: false` skips the fetch when
+  the fqn/id isn't known yet.
+
+Results are cached in React Query under `permissionQueryKeys`, so components asking for the same
+entity share one request. `PermissionProvider` reads the same cache — mixing old and new code
+does not double-fetch.
+
+**Always pass `deleted` when the entity can be soft-deleted.** Every `canEdit*` is gated on it;
+view and delete flags deliberately are not, since delete surfaces restore/purge.
+
+> **Restore affordances need an ungated derivation.** Gating a manage button on a
+> `deleted`-aware flag removes the only path to restore a soft-deleted entity — derive a second,
+> ungated set for those controls (`DataAssetsHeader`'s `ungatedFlags` is the precedent).
+
+## No named flag for the operation?
+
+```ts
+getDerivedPermissionFlags(permissions, deleted).can(Operation.EditStatus);
+```
+
+Same prioritization and `deleted` gating as the named flags.
+
+## Already holding permissions
+
+For a prop-supplied `OperationPermission` or a per-row bulk lookup, call the pure function
+instead of fetching:
+
+```ts
+const flags = getDerivedPermissionFlags(permission ?? DEFAULT_ENTITY_PERMISSION, deleted);
+```
+
+For lists, `useBulkEntityPermissions(resource, fqns)` returns `flagsByFqn` and shares the
+single-entity cache.
+
+## Prioritization — explicit deny beats a broader grant
+
+`canEditTags` is **not** `EditTags || EditAll`. When the payload carries the field key that key
+wins, including when it is `false`; `EditAll` is only the fallback when the key is absent. Do not
+"restore" the old OR — an explicit `EditTags: false` alongside `EditAll: true` must deny.
+
+## Testing
+
+Mock the **hook**, run the **real** derivation over a minimal permission object:
+
+```ts
+mockUseEntityPermissions.mockReturnValue({
+  permissions, isLoading: false, error: null, refresh: jest.fn(),
+  ...getDerivedPermissionFlags(permissions, false),
+});
+```
+
+Components reaching these hooks need a `QueryClientProvider` — use `renderWithQueryClient`
+(`src/test/unit/test-utils.tsx`), or compose a wrapper when the test also needs a router.
+Without it React Query throws *"No QueryClient set"* and the whole suite fails to run.
+
+## Changing behaviour
+
+Behavioural decisions live in `src/utils/permissionPolicy.ts` — change them there, once, rather
+than at call sites.

.claude/rules/frontend-react.md

@@ -6,7 +6,8 @@ paths: "openmetadata-ui/src/main/resources/ui/**/*.{ts,tsx}"
 # Frontend React/TypeScript conventions
 
 Applies to UI `*.{ts,tsx}`. Styling/tokens are in `frontend-styling.md`; component-library choice in
-`component-library.md`; strings/i18n in `i18n.md`; Playwright in `frontend-playwright.md`. For the
+`component-library.md`; strings/i18n in `i18n.md`; Playwright in `frontend-playwright.md`;
+reading permissions in `frontend-permissions.md`. For the
 **formatting procedure** invoke the `ui-checkstyle` skill — do not hand-edit formatting.
 **Folder structure and file naming for new code:
 `openmetadata-ui/src/main/resources/ui/DEVELOPER_HANDBOOK.md`** — read it before creating any new

.github/CODEOWNERS

@@ -13,7 +13,7 @@
 /openmetadata-service/ @open-metadata/backend
 
 # Review from Ingestion owners for changes around Ingestion code
-/ingestion @open-metadata/ingestion @akashverma0786
+/ingestion @open-metadata/ingestion
 
 # Review from Devops owners for changes around workflows
 /.github @akash-jain-10 @harshach @tutte @open-metadata/mergers

.github/playwright/README.md

@@ -17,7 +17,7 @@ SSO stays in its dedicated workflow, while knowledge graph and ontology share on
 ceil(total weighted worker time / (3 workers * 21 minutes * 0.85))
 ```
 
-The common matrix is bounded to 5–24 runners and uses a 21-minute allocation budget. Dedicated lanes use a 20-minute allocation budget. The common lane previously sat a minute below the dedicated lanes, but the chromium suite outgrew what 24 runners could hold at 19 minutes, so full-mode planning aborted outright; 21 minutes restores headroom while staying inside the 25-minute `timeout` wrapper around `npx playwright test` and the 35-minute `playwright-ci` job clock. Note that the allocation budget bounds a whole *shard*, whereas the strict 20-minute ceiling below bounds a single *atomic unit*, so the two are independent. Planner weights use the hook-inclusive observed duration, including retries. Only an exact stable test ID explicitly reported as skipped may retain a zero weight; every other zero-duration observation and every unseen test uses the conservative fallback, and zero weights never transfer through the file/title identity fallback. The versioned bootstrap baseline uses stable expected and skipped observations from the coverage-complete but failed full run `29984209316`, while unexpected and flaky tests retain their prior duration weights from run `29980474263`. It is bootstrap data, not a fabricated successful history; normal planning still uses p75 from the latest three successful full runs when those artifacts exist. This keeps expensive internally parallel suites together instead of multiplying their shared setup across runners. Serial/global behavior stays in one-worker lanes. Large suites listed in `AUDITED_PARALLEL_SUITES` are split at test granularity only after confirming that they are not serial and do not depend on earlier tests. The planner fails when any remaining atomic unit or bounded lane exceeds the 20-minute ceiling.
+The common matrix is bounded to 5–24 runners and uses a 21-minute allocation budget. Dedicated lanes use a 20-minute allocation budget. The common lane previously sat a minute below the dedicated lanes, but the chromium suite outgrew what 24 runners could hold at 19 minutes, so full-mode planning aborted outright; 21 minutes restores headroom while staying inside the `timeout` wrapper around `npx playwright test` (in `playwright-e2e-reusable.yml`) and the `playwright-ci` job clock. Note that the allocation budget bounds a whole *shard*, whereas the strict 20-minute ceiling below bounds a single *atomic unit*, so the two are independent. Planner weights use the hook-inclusive observed duration, including retries. Only an exact stable test ID explicitly reported as skipped may retain a zero weight; every other zero-duration observation and every unseen test uses the conservative fallback, and zero weights never transfer through the file/title identity fallback. The versioned bootstrap baseline uses stable expected and skipped observations from the coverage-complete but failed full run `29984209316`, while unexpected and flaky tests retain their prior duration weights from run `29980474263`. It is bootstrap data, not a fabricated successful history; normal planning still uses p75 from the latest three successful full runs when those artifacts exist. This keeps expensive internally parallel suites together instead of multiplying their shared setup across runners. Serial/global behavior stays in one-worker lanes. Large suites listed in `AUDITED_PARALLEL_SUITES` are split at test granularity only after confirming that they are not serial and do not depend on earlier tests. The planner fails when any remaining atomic unit or bounded lane exceeds the 20-minute ceiling.
 
 The `Basic` and `chromium` projects share that common 24-runner cap and are balanced together; they are not separate pools of standard hosted runners. Isolated ingestion, search, reindex, permission, and global-state lanes are additional because they cannot safely share mutable server state with the common matrix.