@@ -0,0 +1,13 @@
+---
+'@objectstack/plugin-audit': patch
+---
+
+fix(plugin-audit): the `sys_activity` and `sys_audit_log` read gates skip a parent object the caller cannot read without reading it, so the security plugin no longer logs a denial for each skipped object
+
+Clause-②: no
+
+Both gates serve a row only when the caller can read the record it is about. They decide that once per parent object the query's rows name, by reading that object as the caller. For every object the caller holds no object-level read on, plugin-security refused that read and logged `[Security] Access denied` at WARN: one line per object per read, and again for the list's `total`. The console header's activity feed reads `sys_activity` on every page view, so every non-admin page view logged a line for each platform object the stream names (`sys_migration`, `sys_platform_setting`, `sys_user_permission_set`, and others), and real denials were buried among them.
+
+Each gate now asks the security service's `canReadObject` first, with the caller's own context. That is the security middleware's own object-level read check, and it answers without logging. The gate then reads only the objects it admits. An object it refuses contributes no rows, exactly as its refused read did before, so every caller is served the same rows, with the same `total`, as before. A caller's own read of such an object is still refused and still logged, once.
+
+The check can only exclude objects. An admitted object is still read as the caller, and that read still decides row scope, sharing and RLS. If `canReadObject` throws, or answers anything other than `true`, that object's rows are excluded and the gate logs a warning naming the object. On a deployment without the security plugin, or with a security service that does not offer `canReadObject`, every parent object is read as the caller, as before.
@@ -11,6 +11,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { installActivityReadVisibility, parseActivityParent } from './activity-read-visibility.js';
 import { LEDGER_AUDIT_CAPABILITY } from './audit-log-read-visibility.js';
 import type { CommentAccessEngine, CommentReadMiddlewareCtx } from './comment-access-hooks.js';
+import type { ParentObjectReadAdmissionSource } from './parent-record-read-gate.js';
 
 const DENY = { id: '__activity_parent_denied__' };
 const silentLogger = () => ({ info: vi.fn(), warn: vi.fn(), debug: vi.fn() });
@@ -21,6 +22,8 @@ function install(opts: {
   /** parentObject -> readable ids (for any caller), or a thrower. */
   readable?: Record<string, string[] | (() => never)>;
   logger?: ReturnType<typeof silentLogger>;
+  /** The security service's object-level read admission the gate resolves per read; absent: none composed. */
+  admission?: ParentObjectReadAdmissionSource;
 }) {
   let mw!: Mw;
   const calls = { scans: [] as any[], probes: [] as Array<{ object: string; ids: string[]; context: any }> };
@@ -43,7 +46,7 @@ function install(opts: {
     },
     findOne: async () => null,
   };
-  installActivityReadVisibility(engine, opts.logger ?? silentLogger());
+  installActivityReadVisibility(engine, opts.logger ?? silentLogger(), opts.admission ?? (() => undefined));
   return { mw, calls };
 }
 
@@ -209,8 +212,120 @@ describe('installActivityReadVisibility', () => {
     }
   });
 
+  describe('the object-level read admission: a skipped object is not read as the caller', () => {
+    /** Two parent objects; the caller-scoped read refuses `crm_secret` (the middleware's denial). */
+    const scan = () => [
+      { object_name: 'crm_case', record_id: 'c1' },
+      { object_name: 'crm_case', record_id: 'c2' },
+      { object_name: 'crm_secret', record_id: 's1' },
+    ];
+    const readable = {
+      crm_case: ['c1'],
+      crm_secret: () => {
+        throw Object.assign(new Error('denied'), { code: 'PERMISSION_DENIED' });
+      },
+    };
+    const admissionOf = (answer: (object: string) => unknown) => {
+      const canReadObject = vi.fn(async (object: string) => answer(object) as boolean);
+      return { canReadObject, source: () => ({ canReadObject }) };
+    };
+    const CASE_ONLY = { object_name: 'crm_case', record_id: { $in: ['c1'] } };
+
+    it('an object the admission refuses is never read, and the WHERE is the one its refused read gave', async () => {
+      const without = install({ scan, readable });
+      const before = (await read(without.mw)).where;
+      expect(before).toEqual(CASE_ONLY);
+      expect(without.calls.probes.map((p) => p.object).sort()).toEqual(['crm_case', 'crm_secret']);
+
+      const { canReadObject, source } = admissionOf((object) => object !== 'crm_secret');
+      const { mw, calls } = install({ scan, readable, admission: source });
+      expect((await read(mw)).where).toEqual(before);
+      expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
+      expect(canReadObject.mock.calls.map(([object]) => object).sort()).toEqual(['crm_case', 'crm_secret']);
+    });
+
+    it('an admitted object is still read as the caller, and that read decides its rows', async () => {
+      const { source } = admissionOf(() => true);
+      const { mw, calls } = install({ scan, readable: { crm_case: ['c1'], crm_secret: [] }, admission: source });
+      expect((await read(mw)).where).toEqual(CASE_ONLY);
+      expect(calls.probes.find((p) => p.object === 'crm_case')?.ids.sort()).toEqual(['c1', 'c2']);
+      expect(calls.probes.map((p) => p.object).sort()).toEqual(['crm_case', 'crm_secret']);
+    });
+
+    it('asks with the caller envelope, minus the operation-private keys — the envelope the parent read gets', async () => {
+      const { canReadObject, source } = admissionOf(() => true);
+      const { mw, calls } = install({ scan, readable: { crm_case: ['c1'], crm_secret: [] }, admission: source });
+      await read(mw, {
+        context: { userId: 'u1', positions: ['org_member'], __readScope: 'org', __expandRead: true } as any,
+      });
+      for (const [, context] of canReadObject.mock.calls as unknown as Array<[string, Record<string, unknown>]>) {
+        expect(context).toEqual(calls.probes[0].context);
+        expect(context).toMatchObject({ userId: 'u1', positions: ['org_member'] });
+        expect(context).not.toHaveProperty('__readScope');
+        expect(context).not.toHaveProperty('__expandRead');
+      }
+    });
+
+    it('every parent object refused: the deny-all sentinel, and no parent read at all', async () => {
+      const { source } = admissionOf(() => false);
+      const { mw, calls } = install({ scan, readable, admission: source });
+      expect((await read(mw)).where).toEqual(DENY);
+      expect(calls.probes).toEqual([]);
+    });
+
+    it('fails closed: an admission that throws refuses that object, says so, and never widens', async () => {
+      const logger = silentLogger();
+      // The caller-scoped read WOULD serve crm_secret's record here — the
+      // admission's failure must not fall open into it.
+      const { source } = admissionOf((object) => {
+        if (object === 'crm_secret') throw new Error('admission store unreachable');
+        return true;
+      });
+      const { mw, calls } = install({ scan, readable: { crm_case: ['c1'], crm_secret: ['s1'] }, admission: source, logger });
+      expect((await read(mw)).where).toEqual(CASE_ONLY);
+      expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining("read admission for 'crm_secret' failed"));
+    });
+
+    it('fails closed: an answer that is not a plain true refuses', async () => {
+      for (const answer of [undefined, null, 'true', 1, {}]) {
+        const { source } = admissionOf((object) => (object === 'crm_secret' ? answer : true));
+        const { mw, calls } = install({ scan, readable: { crm_case: ['c1'], crm_secret: ['s1'] }, admission: source });
+        expect((await read(mw)).where).toEqual(CASE_ONLY);
+        expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
+      }
+    });
+
+    it('no admission composed — no service, a throwing resolver, or no canReadObject — reads every parent as before', async () => {
+      const sources: Array<ParentObjectReadAdmissionSource> = [
+        () => undefined,
+        () => null,
+        () => {
+          throw new Error("service 'security' not registered");
+        },
+        () => ({}),
+      ];
+      for (const admission of sources) {
+        const { mw, calls } = install({ scan, readable, admission });
+        expect((await read(mw)).where).toEqual(CASE_ONLY);
+        expect(calls.probes.map((p) => p.object).sort()).toEqual(['crm_case', 'crm_secret']);
+      }
+    });
+
+    it('resolves the service on every read, so one that registers after install is asked', async () => {
+      let registered: { canReadObject?: (object: string) => Promise<boolean> } | undefined;
+      const { mw, calls } = install({ scan, readable, admission: () => registered });
+      await read(mw);
+      expect(calls.probes.map((p) => p.object).sort()).toEqual(['crm_case', 'crm_secret']);
+      registered = { canReadObject: async (object: string) => object !== 'crm_secret' };
+      calls.probes.length = 0;
+      expect((await read(mw)).where).toEqual(CASE_ONLY);
+      expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
+    });
+  });
+
   it('is inert on an engine without the middleware seam', () => {
     const engine: CommentAccessEngine = { registerHook: () => {}, find: async () => [], findOne: async () => null };
-    expect(() => installActivityReadVisibility(engine, silentLogger())).not.toThrow();
+    expect(() => installActivityReadVisibility(engine, silentLogger(), () => undefined)).not.toThrow();
   });
 });
@@ -63,6 +63,7 @@ import {
   PARENT_GATE_READ_OPS,
   andIntoWhere,
   computeParentRecordFilter,
+  type ParentObjectReadAdmissionSource,
   parseParentObject,
   parseParentRecord,
   type ParentRecord,
@@ -117,11 +118,15 @@ export function parseActivityParent(row: Record<string, unknown> | null | undefi
  * Install the `sys_activity` read-visibility middleware.
  *
  * Inert on an engine without the middleware seam; `AuditPlugin` says so out
- * loud when that happens.
+ * loud when that happens. `getAdmission` resolves, on every read, the security
+ * service whose object-level read admission is asked before a parent object is
+ * read as the caller (`parent-record-read-gate.ts`, "A skipped object is not
+ * an access attempt").
  */
 export function installActivityReadVisibility(
   engine: CommentAccessEngine,
   logger: CommentAccessLogger,
+  getAdmission: ParentObjectReadAdmissionSource,
 ): void {
   if (typeof engine.registerMiddleware !== 'function') return;
 
@@ -133,7 +138,7 @@ export function installActivityReadVisibility(
         return next();
       }
       try {
-        const filter = await computeParentRecordFilter(engine, ctx, logger, ACTIVITY_GATE);
+        const filter = await computeParentRecordFilter(engine, ctx, logger, ACTIVITY_GATE, getAdmission);
         if (filter) andIntoWhere(ctx, filter);
       } catch (err) {
         // A filter-compute failure must never fall open into a leak.
 
@@ -16,6 +16,7 @@ import {
   isLedgerRowAboutNoRecord,
 } from './audit-log-read-visibility.js';
 import type { CommentAccessEngine, CommentReadMiddlewareCtx } from './comment-access-hooks.js';
+import type { ParentObjectReadAdmissionSource } from './parent-record-read-gate.js';
 
 const DENY = { id: '__audit_log_parent_denied__' };
 const silentLogger = () => ({ info: vi.fn(), warn: vi.fn(), debug: vi.fn() });
@@ -26,6 +27,8 @@ function install(opts: {
   /** parentObject -> readable ids (for any caller), or a thrower. */
   readable?: Record<string, string[] | (() => never)>;
   logger?: ReturnType<typeof silentLogger>;
+  /** The security service's object-level read admission the gate resolves per read; absent: none composed. */
+  admission?: ParentObjectReadAdmissionSource;
 }) {
   let mw!: Mw;
   const calls = { scans: [] as any[], probes: [] as Array<{ object: string; ids: string[] }> };
@@ -48,7 +51,7 @@ function install(opts: {
     },
     findOne: async () => null,
   };
-  installAuditLogReadVisibility(engine, opts.logger ?? silentLogger());
+  installAuditLogReadVisibility(engine, opts.logger ?? silentLogger(), opts.admission ?? (() => undefined));
   return { mw, calls };
 }
 
@@ -120,6 +123,44 @@ describe('installAuditLogReadVisibility', () => {
     expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
   });
 
+  it('asks the object-level read admission first: a refused object is never read, and the WHERE is unchanged', async () => {
+    const scan = () => [
+      { id: 'l1', action: 'create', object_name: 'crm_case', record_id: 'c1' },
+      { id: 'l2', action: 'update', object_name: 'sys_migration', record_id: 'm1' },
+      { id: 'l3', action: 'config_change', object_name: 'sys_setting', record_id: null },
+    ];
+    const readable = {
+      crm_case: ['c1'],
+      sys_migration: () => {
+        throw Object.assign(new Error('denied'), { code: 'PERMISSION_DENIED' });
+      },
+    };
+    const without = install({ scan, readable });
+    const before = (await read(without.mw)).where;
+    expect(without.calls.probes.map((p) => p.object).sort()).toEqual(['crm_case', 'sys_migration']);
+
+    const canReadObject = vi.fn(async (object: string) => object !== 'sys_migration');
+    const { mw, calls } = install({ scan, readable, admission: () => ({ canReadObject }) });
+    expect((await read(mw)).where).toEqual(before);
+    expect(before).toEqual({
+      $or: [{ object_name: 'crm_case', record_id: { $in: ['c1'] } }, { id: { $in: ['l3'] } }],
+    });
+    expect(calls.probes.map((p) => p.object)).toEqual(['crm_case']);
+    expect(canReadObject.mock.calls.map(([object]) => object).sort()).toEqual(['crm_case', 'sys_migration']);
+  });
+
+  it('a holder of the audit capability is exempt before the admission is asked', async () => {
+    const canReadObject = vi.fn(async () => true);
+    const { mw, calls } = install({
+      scan: () => [{ id: 'l1', action: 'create', object_name: 'crm_case', record_id: 'c1' }],
+      admission: () => ({ canReadObject }),
+    });
+    const { where } = await read(mw, { context: { userId: 'u1', systemPermissions: [LEDGER_AUDIT_CAPABILITY] } });
+    expect(where).toBeUndefined();
+    expect(calls.scans).toEqual([]);
+    expect(canReadObject).not.toHaveBeenCalled();
+  });
+
   it('a record action that names no record is excluded, never kept as a row about none', async () => {
     const { mw, calls } = install({
       scan: () => [{ id: 'l1', action: 'update', object_name: 'crm_case', record_id: null }],
@@ -215,7 +256,7 @@ describe('installAuditLogReadVisibility', () => {
 
   it('is inert on an engine without the middleware seam', () => {
     const engine: CommentAccessEngine = { registerHook: () => {}, find: async () => [], findOne: async () => null };
-    expect(() => installAuditLogReadVisibility(engine, silentLogger())).not.toThrow();
+    expect(() => installAuditLogReadVisibility(engine, silentLogger(), () => undefined)).not.toThrow();
   });
 });
 
 
@@ -85,6 +85,7 @@ import {
   PARENT_GATE_READ_OPS,
   andIntoWhere,
   computeParentRecordFilter,
+  type ParentObjectReadAdmissionSource,
   type ParentRecordGate,
 } from './parent-record-read-gate.js';
 
@@ -133,11 +134,15 @@ const LEDGER_GATE: ParentRecordGate = {
  * Install the `sys_audit_log` read-visibility middleware.
  *
  * Inert on an engine without the middleware seam; `AuditPlugin` says so out
- * loud when that happens.
+ * loud when that happens. `getAdmission` resolves, on every read, the security
+ * service whose object-level read admission is asked before a parent object is
+ * read as the caller (`parent-record-read-gate.ts`, "A skipped object is not
+ * an access attempt").
  */
 export function installAuditLogReadVisibility(
   engine: CommentAccessEngine,
   logger: CommentAccessLogger,
+  getAdmission: ParentObjectReadAdmissionSource,
 ): void {
   if (typeof engine.registerMiddleware !== 'function') return;
 
@@ -149,7 +154,7 @@ export function installAuditLogReadVisibility(
         return next();
       }
       try {
-        const filter = await computeParentRecordFilter(engine, ctx, logger, LEDGER_GATE);
+        const filter = await computeParentRecordFilter(engine, ctx, logger, LEDGER_GATE, getAdmission);
         if (filter) andIntoWhere(ctx, filter);
       } catch (err) {
         // A filter-compute failure must never fall open into a leak.
 
@@ -23,6 +23,7 @@ import { installAuditLogFieldRedaction } from './audit-log-field-redaction.js';
 import { installAuditLogReadVisibility } from './audit-log-read-visibility.js';
 import type { FieldVisibilitySource } from './served-fields.js';
 import { installParentFieldQueryGuards } from './parent-field-query-guard.js';
+import type { ParentObjectReadAdmission } from './parent-record-read-gate.js';
 
 /**
  * [#8992] Read/view audit configuration — the per-object opt-in, closed.
@@ -492,7 +493,18 @@ export class AuditPlugin implements Plugin {
           },
           ctx.logger,
         );
-        installActivityReadVisibility(engine as any, ctx.logger);
+        // The parent-record gates ask the security service's object-level read
+        // admission before they read a parent object as the caller, so an
+        // object the caller cannot read is skipped without a logged denial
+        // (`parent-record-read-gate.ts`). Resolved on every read, as below.
+        const getReadAdmission = (): ParentObjectReadAdmission | undefined => {
+          try {
+            return ctx.getService<ParentObjectReadAdmission>('security');
+          } catch {
+            return undefined;
+          }
+        };
+        installActivityReadVisibility(engine as any, ctx.logger, getReadAdmission);
         ctx.logger.info('AuditPlugin: sys_activity parent-record read visibility installed');
         // [#21081] …and of each row it keeps, the value-bearing columns serve a
         // parent field only to a reader the security service serves that field
@@ -524,7 +536,7 @@ export class AuditPlugin implements Plugin {
         // query guard above judges a query first (a refused query never pays
         // this gate's pre-scan), and the field redaction narrows only the rows
         // this gate keeps.
-        installAuditLogReadVisibility(engine as any, ctx.logger);
+        installAuditLogReadVisibility(engine as any, ctx.logger, getReadAdmission);
         ctx.logger.info('AuditPlugin: sys_audit_log parent-record read visibility installed');
       } else {
         ctx.logger.warn(