@cosmicdrift/kumiko-bundled-features 1.0.0 → 2.0.0

package/src/agent-tools/__tests__/tool-dispatch.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import type { SessionUser } from "@cosmicdrift/kumiko-framework/engine";
+import { dispatchToolCall } from "../tool-dispatch";
+import type { ToolDispatchDescriptor } from "../types";
+
+const CALLER: SessionUser = { id: "user-1", tenantId: "tenant-1", roles: ["member"] };
+
+const DISPATCH_TABLE = new Map<string, ToolDispatchDescriptor>([
+  [
+    "search_vendor",
+    { kind: "search", entityName: "vendor", qn: "vendor-feature:query:vendor:list" },
+  ],
+  [
+    "find_vendor_by_iban",
+    {
+      kind: "findBy",
+      entityName: "vendor",
+      fieldName: "iban",
+      qn: "vendor-feature:query:vendor:list",
+    },
+  ],
+]);
+
+function recordingDispatcher() {
+  const calls: { type: string; payload: unknown; user: SessionUser }[] = [];
+  return {
+    calls,
+    query: async (type: string, payload: unknown, user: SessionUser) => {
+      calls.push({ type, payload, user });
+      return { rows: [{ id: "vendor-1" }] };
+    },
+  };
+}
+
+describe("dispatchToolCall", () => {
+  test("unknown tool name returns an error result without calling the dispatcher", async () => {
+    const dispatcher = recordingDispatcher();
+    const result = await dispatchToolCall(dispatcher, CALLER, "search_ghost", {}, DISPATCH_TABLE);
+
+    expect(result).toEqual({ ok: false, error: 'Unknown tool "search_ghost"' });
+    expect(dispatcher.calls).toHaveLength(0);
+  });
+
+  test("search tool dispatches to <entity>:list with a search payload, using the caller's identity", async () => {
+    const dispatcher = recordingDispatcher();
+    const result = await dispatchToolCall(
+      dispatcher,
+      CALLER,
+      "search_vendor",
+      { query: "Müller GmbH" },
+      DISPATCH_TABLE,
+    );
+
+    expect(result).toEqual({ ok: true, data: { rows: [{ id: "vendor-1" }] } });
+    expect(dispatcher.calls).toEqual([
+      {
+        type: "vendor-feature:query:vendor:list",
+        payload: { search: "Müller GmbH", limit: 10 },
+        user: CALLER,
+      },
+    ]);
+  });
+
+  test("search tool without a query argument returns an error, no dispatcher call", async () => {
+    const dispatcher = recordingDispatcher();
+    const result = await dispatchToolCall(dispatcher, CALLER, "search_vendor", {}, DISPATCH_TABLE);
+
+    expect(result.ok).toBe(false);
+    expect(dispatcher.calls).toHaveLength(0);
+  });
+
+  test("findBy tool dispatches to <entity>:list with an exact filter payload", async () => {
+    const dispatcher = recordingDispatcher();
+    const result = await dispatchToolCall(
+      dispatcher,
+      CALLER,
+      "find_vendor_by_iban",
+      { iban: "DE89370400440532013000" },
+      DISPATCH_TABLE,
+    );
+
+    expect(result).toEqual({ ok: true, data: { rows: [{ id: "vendor-1" }] } });
+    expect(dispatcher.calls).toEqual([
+      {
+        type: "vendor-feature:query:vendor:list",
+        payload: {
+          filter: { field: "iban", op: "eq", value: "DE89370400440532013000" },
+          limit: 10,
+        },
+        user: CALLER,
+      },
+    ]);
+  });
+
+  test("findBy tool without its required field argument returns an error, no dispatcher call", async () => {
+    const dispatcher = recordingDispatcher();
+    const result = await dispatchToolCall(
+      dispatcher,
+      CALLER,
+      "find_vendor_by_iban",
+      {},
+      DISPATCH_TABLE,
+    );
+
+    expect(result.ok).toBe(false);
+    expect(dispatcher.calls).toHaveLength(0);
+  });
+
+  test("a dispatcher rejection (e.g. missing handler or failed cap check) becomes an error result, not a throw", async () => {
+    const dispatcher = {
+      query: async () => {
+        throw new Error("no handler registered for qn 'vendor:list'");
+      },
+    };
+
+    const result = await dispatchToolCall(
+      dispatcher,
+      CALLER,
+      "search_vendor",
+      { query: "anything" },
+      DISPATCH_TABLE,
+    );
+
+    expect(result).toEqual({ ok: false, error: "no handler registered for qn 'vendor:list'" });
+  });
+});

package/src/agent-tools/index.ts

@@ -0,0 +1,9 @@
+export { buildToolCatalog } from "./tool-catalog";
+export type { ToolCallResult, ToolDispatcher } from "./tool-dispatch";
+export { dispatchToolCall } from "./tool-dispatch";
+export type {
+  RegistrySearchView,
+  ToolCatalog,
+  ToolDefinition,
+  ToolDispatchDescriptor,
+} from "./types";

package/src/agent-tools/tool-catalog.ts

@@ -0,0 +1,130 @@
+import type { EntityDefinition, FieldDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import type {
+  RegistrySearchView,
+  ToolCatalog,
+  ToolDefinition,
+  ToolDispatchDescriptor,
+} from "./types";
+
+/** Field types that declare `filterable` (per `packages/framework/src/engine/types/fields.ts`).
+ *  Mapped to the JSON-Schema type an LLM tool-call argument should use. `undefined` = field type
+ *  is skipped for exact-lookup tools (not filterable at the type level). */
+function jsonSchemaTypeForField(
+  field: FieldDefinition,
+): Readonly<Record<string, unknown>> | undefined {
+  switch (field.type) {
+    case "text":
+    case "multiSelect":
+    case "date":
+    case "timestamp":
+    case "locatedTimestamp":
+      return { type: "string" };
+    case "select":
+      return { type: "string", enum: field.options };
+    case "boolean":
+      return { type: "boolean" };
+    case "number":
+    case "bigInt":
+    case "decimal":
+    case "money":
+      return { type: "number" };
+    case "reference":
+      return { type: "string", description: `ID referencing "${field.entity}"` };
+    default:
+      return undefined;
+  }
+}
+
+function isFilterable(field: FieldDefinition): boolean {
+  return "filterable" in field && field.filterable === true;
+}
+
+function buildSearchTool(entityName: string, searchableFields: readonly string[]): ToolDefinition {
+  return {
+    name: `search_${entityName}`,
+    description: `Full-text search over ${entityName} across fields: ${searchableFields.join(", ")}. Returns ranked candidates, not a single answer — may need a follow-up find_${entityName}_by_* call to disambiguate.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Free-text search query" },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+  };
+}
+
+function buildFindByTool(
+  entityName: string,
+  fieldName: string,
+  fieldSchema: Readonly<Record<string, unknown>>,
+): ToolDefinition {
+  return {
+    name: `find_${entityName}_by_${fieldName}`,
+    description: `Exact lookup of ${entityName} where ${fieldName} matches.`,
+    inputSchema: {
+      type: "object",
+      properties: { [fieldName]: fieldSchema },
+      required: [fieldName],
+      additionalProperties: false,
+    },
+  };
+}
+
+/** True for a `:list`-verb entity query handler, e.g. "my-feature:query:vendor:list" for entity
+ *  "vendor" — the only handler shape whose payload accepts `search`/`filter` (see
+ *  `packages/framework/src/db/event-store-executor-read.ts`). Handler-first iteration, not
+ *  name-reconstruction: `entityName` here always comes from `registry.getHandlerEntity(qn)`,
+ *  the registry's own answer for this exact qn, never guessed from kebab-casing rules. */
+function isListHandlerQn(qn: string, entityName: string): boolean {
+  return qn.endsWith(`:${entityName}:list`);
+}
+
+function addToolsForListHandler(
+  registry: RegistrySearchView,
+  qn: string,
+  entityName: string,
+  entity: EntityDefinition,
+  tools: ToolDefinition[],
+  dispatchTable: Map<string, ToolDispatchDescriptor>,
+): void {
+  const searchableFields = registry.getSearchableFields(entityName);
+  if (searchableFields.length > 0) {
+    const tool = buildSearchTool(entityName, searchableFields);
+    tools.push(tool);
+    dispatchTable.set(tool.name, { kind: "search", entityName, qn });
+  }
+
+  for (const [fieldName, field] of Object.entries(
+    entity.fields as Record<string, FieldDefinition>,
+  )) {
+    if (!isFilterable(field)) continue;
+    const fieldSchema = jsonSchemaTypeForField(field);
+    if (!fieldSchema) continue;
+    const tool = buildFindByTool(entityName, fieldName, fieldSchema);
+    tools.push(tool);
+    dispatchTable.set(tool.name, { kind: "findBy", entityName, fieldName, qn });
+  }
+}
+
+/** Registry snapshot → agent tool catalog. Pure, deterministic, no I/O, no permission check —
+ *  every tool here is a name+schema only; `tool-dispatch.ts` is what actually calls a
+ *  permission-checked query handler when the LLM invokes one of these by name. Iterates mounted
+ *  `:list` handlers (not `getAllEntities()`) so the catalog never advertises a tool for an entity
+ *  that has no callable list handler — a wasted tool-call the LLM would just fail on. */
+export function buildToolCatalog(registry: RegistrySearchView): ToolCatalog {
+  const tools: ToolDefinition[] = [];
+  const dispatchTable = new Map<string, ToolDispatchDescriptor>();
+
+  for (const [qn] of registry.getAllQueryHandlers()) {
+    const entityName = registry.getHandlerEntity(qn);
+    if (!entityName || !isListHandlerQn(qn, entityName)) continue;
+
+    const entity = registry.getEntity(entityName);
+    if (!entity) continue;
+
+    addToolsForListHandler(registry, qn, entityName, entity, tools, dispatchTable);
+  }
+
+  return { tools, dispatchTable };
+}

package/src/agent-tools/tool-dispatch.ts

@@ -0,0 +1,82 @@
+import type { SessionUser } from "@cosmicdrift/kumiko-framework/engine";
+import type { ToolDispatchDescriptor } from "./types";
+
+/** Narrow view of `Dispatcher` (packages/framework/src/pipeline/dispatcher.ts) — dispatch only
+ *  ever needs `query`, and this keeps the module testable without constructing a real Dispatcher.
+ *  Callers pass either the app's real `dispatcher` or `{ query: ctx.queryAs }` from inside a
+ *  handler — both run the same `executeQuery` pipeline with a caller-supplied SessionUser, never
+ *  `systemQuery`/`createSystemUser`/`createAnonymousUser` (all of which drop the caller's identity). */
+export type ToolDispatcher = {
+  query(type: string, payload: unknown, user: SessionUser): Promise<unknown>;
+};
+
+export type ToolCallResult =
+  | { readonly ok: true; readonly data: unknown }
+  | { readonly ok: false; readonly error: string };
+
+const RESULT_LIMIT = 10;
+
+/** Execute one LLM-issued tool call. `callerUser` MUST be the real Tenant+User identity of
+ *  whoever's search this is running on behalf of — every call goes through `<entity>:list`,
+ *  the same handler + permission pipeline as a normal HTTP list request (search/filter are both
+ *  native `<entity>:list` payload fields, see `packages/framework/src/db/event-store-executor-read.ts`).
+ *  Never throws — a missing tool, a missing argument, or a rejected handler call (e.g. no
+ *  `<entity>:list` handler mounted, or a cap check failing) all come back as `{ ok: false }` so
+ *  the agent loop can feed the error back to the model instead of crashing. */
+export async function dispatchToolCall(
+  dispatcher: ToolDispatcher,
+  callerUser: SessionUser,
+  toolName: string,
+  toolInput: Readonly<Record<string, unknown>>,
+  dispatchTable: ReadonlyMap<string, ToolDispatchDescriptor>,
+): Promise<ToolCallResult> {
+  const descriptor = dispatchTable.get(toolName);
+  if (!descriptor) {
+    return { ok: false, error: `Unknown tool "${toolName}"` };
+  }
+
+  const payload =
+    descriptor.kind === "search"
+      ? buildSearchPayload(toolName, toolInput)
+      : buildFindByPayload(toolName, descriptor.fieldName, toolInput);
+  if (!payload.ok) {
+    return payload;
+  }
+
+  try {
+    const data = await dispatcher.query(descriptor.qn, payload.value, callerUser);
+    return { ok: true, data };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+type PayloadResult =
+  | { readonly ok: true; readonly value: Readonly<Record<string, unknown>> }
+  | { readonly ok: false; readonly error: string };
+
+function buildSearchPayload(
+  toolName: string,
+  toolInput: Readonly<Record<string, unknown>>,
+): PayloadResult {
+  const query = toolInput["query"];
+  if (typeof query !== "string" || query.length === 0) {
+    return { ok: false, error: `Tool "${toolName}" requires a non-empty string "query" argument` };
+  }
+  return { ok: true, value: { search: query, limit: RESULT_LIMIT } };
+}
+
+function buildFindByPayload(
+  toolName: string,
+  fieldName: string,
+  toolInput: Readonly<Record<string, unknown>>,
+): PayloadResult {
+  const value = toolInput[fieldName];
+  if (value === undefined) {
+    return { ok: false, error: `Tool "${toolName}" requires a "${fieldName}" argument` };
+  }
+  return {
+    ok: true,
+    value: { filter: { field: fieldName, op: "eq", value }, limit: RESULT_LIMIT },
+  };
+}

package/src/agent-tools/types.ts

@@ -0,0 +1,38 @@
+import type { EntityDefinition, QueryHandlerDef } from "@cosmicdrift/kumiko-framework/engine";
+
+/** Mirrors `ToolDefinition` in `@cosmicdriftgamestudio/kumiko-ai-foundation` (providers/types.ts)
+ *  field-for-field so a generated catalog needs no translation layer at the call site. Kept as
+ *  a local, dependency-free type — agent-tools has no ai-foundation/enterprise dependency. */
+export type ToolDefinition = {
+  readonly name: string;
+  readonly inputSchema: Readonly<Record<string, unknown>>;
+  readonly description: string;
+};
+
+/** Narrow, handler-first view of `Registry` — iterate query handlers (real, mounted, callable
+ *  QNs) rather than entities, so the catalog never advertises a tool for an entity that has no
+ *  `:list` handler mounted. Small enough that tests pass a plain object instead of a full
+ *  64-getter Registry. */
+export type RegistrySearchView = {
+  getAllQueryHandlers(): ReadonlyMap<string, QueryHandlerDef>;
+  getHandlerEntity(qualifiedHandler: string): string | undefined;
+  getEntity(entityName: string): EntityDefinition | undefined;
+  getSearchableFields(entityName: string): readonly string[];
+};
+
+/** How to actually execute a generated tool — kept out of `ToolDefinition` (which mirrors the
+ *  LLM-facing shape exactly) so dispatch never has to re-parse the tool name back into an entity
+ *  + field. `buildToolCatalog` produces one of these per tool, keyed by tool name. */
+export type ToolDispatchDescriptor =
+  | { readonly kind: "search"; readonly entityName: string; readonly qn: string }
+  | {
+      readonly kind: "findBy";
+      readonly entityName: string;
+      readonly fieldName: string;
+      readonly qn: string;
+    };
+
+export type ToolCatalog = {
+  readonly tools: readonly ToolDefinition[];
+  readonly dispatchTable: ReadonlyMap<string, ToolDispatchDescriptor>;
+};

package/src/audit/__tests__/audit-screens.boot.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { access, validateBoot } from "@cosmicdrift/kumiko-framework/engine";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { createConfigFeature } from "../../config/feature";
+import { AUDIT_LOG_DETAIL_SCREEN_ID, AUDIT_LOG_SCREEN_ID, AuditQueries } from "../constants";
+import { createAuditFeature } from "../feature";
+
+describe("audit log screen + handler access alignment", () => {
+  const features = [createConfigFeature(), createAuditFeature()];
+
+  test("boot-validates with audit-log screen registered", () => {
+    expect(() => validateBoot(features)).not.toThrow();
+  });
+
+  test("audit-log screen is custom, access.admin-gated", () => {
+    const audit = createAuditFeature();
+    const screen = audit.screens[AUDIT_LOG_SCREEN_ID];
+    if (screen?.type !== "custom") {
+      throw new Error(`expected a custom screen for ${AUDIT_LOG_SCREEN_ID}, got ${screen?.type}`);
+    }
+    if (!("access" in screen) || !screen.access || !("roles" in screen.access)) {
+      throw new Error(`expected role-gated access on ${AUDIT_LOG_SCREEN_ID}`);
+    }
+    expect(screen.access.roles).toEqual(access.admin);
+  });
+
+  test("audit-log-detail screen is custom, admin-gated, breadcrumb-linked to list", () => {
+    const audit = createAuditFeature();
+    const screen = audit.screens[AUDIT_LOG_DETAIL_SCREEN_ID];
+    if (screen?.type !== "custom") {
+      throw new Error(
+        `expected a custom screen for ${AUDIT_LOG_DETAIL_SCREEN_ID}, got ${screen?.type}`,
+      );
+    }
+    if (!("listScreenId" in screen)) {
+      throw new Error(`expected listScreenId on ${AUDIT_LOG_DETAIL_SCREEN_ID}`);
+    }
+    expect(screen.listScreenId).toBe(AUDIT_LOG_SCREEN_ID);
+    if (!("access" in screen) || !screen.access || !("roles" in screen.access)) {
+      throw new Error(`expected role-gated access on ${AUDIT_LOG_DETAIL_SCREEN_ID}`);
+    }
+    expect(screen.access.roles).toEqual(access.admin);
+  });
+
+  test("audit queries use access.admin (screen ⊆ handler)", () => {
+    const audit = createAuditFeature();
+    expect(rolesOf(audit.queryHandlers["list"]?.access)).toEqual([...access.admin]);
+    expect(rolesOf(audit.queryHandlers["details"]?.access)).toEqual([...access.admin]);
+    void AuditQueries;
+  });
+});

package/src/audit/__tests__/audit-security.integration.test.ts

@@ -0,0 +1,201 @@
+// Security integration tests for audit-log HTTP surface.
+// Real HTTP via setupTestStack — no mocks.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import {
+  access,
+  createEntity,
+  createTextField,
+  defineEntityWriteHandler,
+  defineFeature,
+  type SessionUser,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import {
+  createTestUser,
+  resetEventStore,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+  testTenantId,
+  unsafeCreateEntityTable,
+  unsafePushTables,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { rolesOf } from "@cosmicdrift/kumiko-framework/testing";
+import { createConfigFeature } from "../../config/feature";
+import { hashPassword } from "../../shared";
+import { createTenantFeature } from "../../tenant/feature";
+import { tenantMembershipsTable } from "../../tenant/membership-table";
+import { tenantEntity } from "../../tenant/schema/tenant";
+import { seedTenant, seedTenantMembership } from "../../tenant/seeding";
+import { createUserFeature } from "../../user/feature";
+import { userEntity } from "../../user/schema/user";
+import { seedUser } from "../../user/seeding";
+import { AUDIT_LOG_SCREEN_ID, AuditQueries } from "../constants";
+import { createAuditFeature } from "../feature";
+
+const widgetEntity = createEntity({
+  table: "audit_sec_widgets",
+  fields: {
+    name: createTextField({ required: true }),
+  },
+});
+
+const widgetFeature = defineFeature("audit-sec-widgets", (r) => {
+  r.entity("widget", widgetEntity);
+  r.writeHandler(
+    defineEntityWriteHandler("widget:create", widgetEntity, {
+      access: { roles: ["Admin", "User", "SystemAdmin", "TenantAdmin"] },
+    }),
+  );
+});
+
+let stack: TestStack;
+let TENANT_ID: TenantId;
+let tenantAdminId: string;
+
+const systemAdmin = TestUsers.systemAdmin;
+
+function tenantAdmin(): SessionUser {
+  return { id: tenantAdminId, tenantId: TENANT_ID, roles: ["TenantAdmin"] };
+}
+
+function regularUser(): SessionUser {
+  return createTestUser({ id: 42, tenantId: TENANT_ID, roles: ["User"] });
+}
+
+beforeAll(async () => {
+  stack = await setupTestStack({
+    features: [
+      createConfigFeature(),
+      createUserFeature(),
+      createTenantFeature(),
+      widgetFeature,
+      createAuditFeature(),
+    ],
+  });
+  await unsafeCreateEntityTable(stack.db, userEntity);
+  await unsafeCreateEntityTable(stack.db, tenantEntity);
+  await unsafeCreateEntityTable(stack.db, widgetEntity);
+  await unsafePushTables(stack.db, { tenantMembershipsTable });
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  await resetEventStore(stack);
+  await asRawClient(stack.db).unsafe(`TRUNCATE audit_sec_widgets`);
+  TENANT_ID = testTenantId(1);
+  await seedTenant(stack.db, { id: TENANT_ID, key: "audit-sec", name: "Audit Sec" });
+  ({ id: tenantAdminId } = await seedUser(stack.db, {
+    email: "taudit@example.com",
+    displayName: "TAudit",
+    passwordHash: await hashPassword("pw-audit-1234"),
+    emailVerified: true,
+  }));
+  await seedTenantMembership(stack.db, {
+    userId: tenantAdminId,
+    tenantId: TENANT_ID,
+    roles: ["TenantAdmin"],
+  });
+});
+
+describe("access matrix: audit list uses access.admin", () => {
+  test("handler and screen share access.admin", () => {
+    const adminRoles = [...access.admin];
+    expect(rolesOf(stack.registry.getQueryHandler(AuditQueries.list)?.access)).toEqual(adminRoles);
+    const audit = createAuditFeature();
+    const screen = audit.screens[AUDIT_LOG_SCREEN_ID];
+    if (screen && "access" in screen && screen.access && "roles" in screen.access) {
+      expect(screen.access.roles).toEqual(adminRoles);
+    }
+  });
+});
+
+describe("TenantAdmin can query audit log for own tenant", () => {
+  test("TenantAdmin lists events after write in tenant", async () => {
+    await stack.http.writeOk(
+      "audit-sec-widgets:write:widget:create",
+      { name: "audited" },
+      tenantAdmin(),
+    );
+    const res = await stack.http.queryOk<{ rows: readonly { type: string }[] }>(
+      AuditQueries.list,
+      {},
+      tenantAdmin(),
+    );
+    expect(res.rows.some((r) => r.type === "widget.created")).toBe(true);
+  });
+});
+
+describe("regular User denied audit log", () => {
+  test("403 on audit:query:list", async () => {
+    const res = await stack.http.query(AuditQueries.list, {}, regularUser());
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("systemAdmin retains audit access", () => {
+  test("SystemAdmin can list", async () => {
+    await stack.http.writeOk("audit-sec-widgets:write:widget:create", { name: "sys" }, systemAdmin);
+    const res = await stack.http.queryOk<{ rows: readonly unknown[] }>(
+      AuditQueries.list,
+      {},
+      systemAdmin,
+    );
+    expect(res.rows.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe("tenant isolation", () => {
+  test("TenantAdmin does not see events from another tenant", async () => {
+    const otherTenant = testTenantId(2);
+    await seedTenant(stack.db, { id: otherTenant, key: "audit-other", name: "Other" });
+    await seedTenantMembership(stack.db, {
+      userId: tenantAdminId,
+      tenantId: otherTenant,
+      roles: ["TenantAdmin"],
+    });
+    await stack.http.writeOk(
+      "audit-sec-widgets:write:widget:create",
+      { name: "other-tenant" },
+      { id: tenantAdminId, tenantId: otherTenant, roles: ["TenantAdmin"] },
+    );
+
+    const ownTenantRes = await stack.http.queryOk<{ rows: readonly { type: string }[] }>(
+      AuditQueries.list,
+      {},
+      tenantAdmin(),
+    );
+    expect(ownTenantRes.rows.some((r) => r.type === "widget.created")).toBe(false);
+  });
+});
+
+describe("audit list filters", () => {
+  test("rejects from after to", async () => {
+    const res = await stack.http.query(
+      AuditQueries.list,
+      { from: "2026-01-02T00:00:00.000Z", to: "2026-01-01T00:00:00.000Z" },
+      tenantAdmin(),
+    );
+    expect([400, 422]).toContain(res.status);
+  });
+
+  test("filters by eventType within tenant", async () => {
+    await stack.http.writeOk(
+      "audit-sec-widgets:write:widget:create",
+      { name: "filter-me" },
+      tenantAdmin(),
+    );
+    const res = await stack.http.queryOk<{ rows: readonly { type: string }[] }>(
+      AuditQueries.list,
+      { eventType: "widget.created" },
+      tenantAdmin(),
+    );
+    expect(res.rows.length).toBeGreaterThanOrEqual(1);
+    expect(res.rows.every((r) => r.type === "widget.created")).toBe(true);
+  });
+});