@stigmer/server 3.15.3-dev.20260914100347 → 3.15.3-dev.20260916211208

package/src/authorization/__tests__/drivers.ts

@@ -0,0 +1,70 @@
+/**
+ * The two store drivers as test fixtures, for every authorization test
+ * that must hold on sqlite AND Postgres (the source, the Authorizer, the
+ * directory, the fire caller): `describe.each(driverFixtures(kinds))`
+ * opens a fresh sqlite file per test, or the shared Postgres test
+ * database with the named kinds cleared — the shape derived-tuples.test.ts
+ * established, lifted here so four files do not carry four copies.
+ *
+ * Postgres is skipped, never failed, when no `TEST_DATABASE_URL` is set
+ * (the store's own convention); `dropPostgresFixture` is the `afterAll`
+ * each file registers so the database it created is dropped.
+ */
+import type { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import type { Store } from "../../store/interface.js";
+import { PostgresStore } from "../../store/postgres/store.js";
+import {
+  createTestDatabase,
+  testDatabaseAdminUrl,
+  type TestDatabase,
+} from "../../store/postgres/__tests__/support.js";
+import { tempStore } from "../../store/sqlite/__tests__/support.js";
+
+export interface OpenedStore {
+  readonly store: Store;
+  close(): Promise<void>;
+}
+
+export interface DriverFixture {
+  readonly name: string;
+  readonly skip: boolean;
+  open(): Promise<OpenedStore>;
+}
+
+let postgresDatabase: TestDatabase | undefined;
+
+/** Both drivers; `seededKinds` are cleared on the shared Postgres database before each open. */
+export function driverFixtures(
+  seededKinds: ReadonlyArray<ApiResourceKind>,
+): ReadonlyArray<DriverFixture> {
+  return [
+    {
+      name: "sqlite",
+      skip: false,
+      async open() {
+        const temp = tempStore();
+        return { store: temp.store, close: () => temp.cleanup() };
+      },
+    },
+    {
+      name: "postgres",
+      skip: testDatabaseAdminUrl() === undefined,
+      async open() {
+        if (postgresDatabase === undefined) {
+          postgresDatabase = await createTestDatabase();
+        }
+        const store = await PostgresStore.open(postgresDatabase.databaseUrl);
+        for (const kind of seededKinds) {
+          await store.deleteResourcesByKind(kind);
+        }
+        return { store, close: () => store.close() };
+      },
+    },
+  ];
+}
+
+export async function dropPostgresFixture(): Promise<void> {
+  await postgresDatabase?.drop();
+  postgresDatabase = undefined;
+}

package/src/authorization/__tests__/evaluator.test.ts

@@ -0,0 +1,359 @@
+/**
+ * Pins the evaluator's semantics the store tests cannot express (the
+ * cloud's `.fga.yaml` documents prove the model's answers; this file
+ * proves the machinery under them): how a person matches a tuple, what
+ * the `allow_public` context does, that a direct tuple outside the line's
+ * type restriction is ignored (model drift fails closed), how far a
+ * resolution may walk, and that a declaration cycle or an undeclared
+ * target is a thrown fault and never a silent deny.
+ *
+ * The fixture source is the in-memory one the store-test kit uses, so the
+ * two proofs share one tuple vocabulary. Where a case needs a shape the
+ * real model does not have (a cycle, a chain past the depth bound), it
+ * declares a throwaway model with `declareKind`; everything else runs
+ * over the built-in model so the fixtures are real relations.
+ */
+import { describe, expect, it } from "vitest";
+
+import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+
+import {
+  AuthorizationEvaluationError,
+  MAX_RESOLUTION_DEPTH,
+  checkRelation,
+} from "../evaluator.js";
+import { builtInModel, newModel } from "../model/index.js";
+import {
+  computed,
+  declareKind,
+  direct,
+  from,
+  objectOf,
+  publicWith,
+  union,
+  usersetOf,
+} from "../model/rewrite.js";
+import type { Person, Tuple, TupleSource } from "../tuples.js";
+import {
+  newInMemoryTupleSource,
+  parseObjectRef,
+  parseSubject,
+} from "../tuples.js";
+
+/** `object#relation@subject` in the FGA tuple notation, the fixtures' own spelling. */
+function tuple(text: string): Tuple {
+  const [objectAndRelation, subject] = text.split("@") as [string, string];
+  const [object, relation] = objectAndRelation.split("#") as [string, string];
+  return {
+    object: parseObjectRef(object),
+    relation,
+    subject: parseSubject(subject),
+  };
+}
+
+function person(accountId: string, ...aliases: string[]): Person {
+  return { accountId, aliases: new Set([accountId, ...aliases]) };
+}
+
+const RESOLVE = { allow: true };
+const LIST = { allow: false };
+
+async function allowed(
+  source: TupleSource,
+  object: string,
+  relation: string,
+  who: Person,
+  context = RESOLVE,
+): Promise<boolean> {
+  return checkRelation(
+    { model: builtInModel, source },
+    parseObjectRef(object),
+    relation,
+    who,
+    context,
+  );
+}
+
+describe("a person against a direct tuple", () => {
+  const source = newInMemoryTupleSource([
+    tuple("agent:a#organization@organization:acme"),
+    tuple("agent:a#owner@identity_account:auth0|carol"),
+  ]);
+
+  it("matches on any alias, so a row stamped with the 3.14 issuer subject is still its creator's", async () => {
+    const carol = person("ida_carol", "auth0|carol");
+    expect(await allowed(source, "agent:a", "can_edit", carol)).toBe(true);
+    expect(
+      await allowed(source, "agent:a", "can_edit", person("ida_carol")),
+    ).toBe(false);
+  });
+
+  it("a tuple naming the empty stamp or the laptop's `system` placeholder reaches no person — the derivation never emits one, and `personFor` never builds one (tuples.test.ts)", async () => {
+    const stamped = newInMemoryTupleSource([
+      tuple("agent:b#owner@identity_account:"),
+      tuple("agent:c#owner@identity_account:system"),
+    ]);
+    const someone = person("ida_someone", "auth0|someone");
+    expect(await allowed(stamped, "agent:b", "can_edit", someone)).toBe(false);
+    expect(await allowed(stamped, "agent:c", "can_edit", someone)).toBe(false);
+  });
+});
+
+describe("the public wildcard and its condition", () => {
+  const publicViewer = (object: string): Tuple => ({
+    object: parseObjectRef(object),
+    relation: "viewer",
+    subject: {
+      form: "wildcard",
+      type: "identity_account",
+      condition: "allow_public",
+    },
+  });
+  const source = newInMemoryTupleSource([
+    tuple("agent:open#organization@organization:acme"),
+    publicViewer("agent:open"),
+  ]);
+  const stranger = person("ida_mallory");
+
+  it("reads for anyone on a point check (the cloud's `allow: true`) and for nobody in a listing (`allow: false`)", async () => {
+    expect(await allowed(source, "agent:open", "can_view", stranger)).toBe(
+      true,
+    );
+    expect(
+      await allowed(source, "agent:open", "can_view", stranger, LIST),
+    ).toBe(false);
+  });
+
+  it("ignores a wildcard tuple that carries no condition where the line demands one — a tuple the cloud could never have written", async () => {
+    const bare = newInMemoryTupleSource([
+      tuple("agent:open#viewer@identity_account:*"),
+    ]);
+    expect(await allowed(bare, "agent:open", "can_view", stranger)).toBe(false);
+  });
+
+  it("is a thrown fault under a condition the transcript names but the evaluator does not know — a model that grew a condition", async () => {
+    const grown = declareKind({
+      kind: ApiResourceKind.agent,
+      schema: AgentSchema,
+      source: "test/grown.fga",
+      relations: [
+        ["viewer", direct(publicWith("identity_account", "after_hours"))],
+      ],
+    });
+    const afterHours = newInMemoryTupleSource([
+      {
+        object: parseObjectRef("agent:open"),
+        relation: "viewer",
+        subject: {
+          form: "wildcard",
+          type: "identity_account",
+          condition: "after_hours",
+        },
+      },
+    ]);
+    await expect(
+      checkRelation(
+        { model: newModel([grown]), source: afterHours },
+        parseObjectRef("agent:open"),
+        "viewer",
+        stranger,
+        RESOLVE,
+      ),
+    ).rejects.toMatchObject({ reason: "unknown-condition" });
+  });
+});
+
+describe("type restrictions on a direct line", () => {
+  it("honours a userset subject only where the line lists it — `organization.owner` is `[identity_account]`, so another organization's member userset on it grants nothing", async () => {
+    // A tuple the cloud could never have written (the write would be
+    // rejected by the type restriction); the evaluator refuses it the
+    // same way, so a derivation that drifts from the model denies
+    // instead of allowing.
+    const source = newInMemoryTupleSource([
+      tuple("organization:acme#member@identity_account:ida_dave"),
+      tuple("organization:other#owner@organization:acme#member"),
+    ]);
+    expect(
+      await allowed(
+        source,
+        "organization:other",
+        "can_delete",
+        person("ida_dave"),
+      ),
+    ).toBe(false);
+  });
+
+  it("resolves an allowed userset through the parent's own relation, ladder included", async () => {
+    const source = newInMemoryTupleSource([
+      tuple("organization:acme#owner@identity_account:ida_root"),
+      tuple("agent:team#organization@organization:acme"),
+      tuple("agent:team#viewer@organization:acme#viewer"),
+    ]);
+    // owner ⊂ admin ⊂ member ⊂ viewer: the owner satisfies organization#viewer.
+    expect(
+      await allowed(source, "agent:team", "can_view", person("ida_root")),
+    ).toBe(true);
+  });
+});
+
+describe("relations and kinds the model does not declare", () => {
+  const source = newInMemoryTupleSource([
+    tuple("agent:a#organization@organization:acme"),
+    tuple("agent:a#owner@identity_account:ida_carol"),
+  ]);
+
+  it("an undeclared relation on a declared kind is false — the ruled answer: deny, never INTERNAL", async () => {
+    expect(
+      await allowed(source, "agent:a", "can_read_secrets", person("ida_carol")),
+    ).toBe(false);
+  });
+
+  it("an undeclared kind as the TARGET is a thrown fault — the driver refused unserved kinds before, so reaching here is a registry gap", async () => {
+    await expect(
+      allowed(source, "identity_provider:idp", "can_view", person("ida_carol")),
+    ).rejects.toMatchObject({ reason: "undeclared-target-kind" });
+  });
+
+  it("an undeclared kind reached through a hop yields nothing — `agent.platform_viewer` walks `identity_provider#platform_user`", async () => {
+    const platform = newInMemoryTupleSource([
+      tuple("agent:p#organization@organization:acme"),
+      tuple("agent:p#platform_viewer@identity_provider:idp#platform_user"),
+    ]);
+    expect(
+      await allowed(platform, "agent:p", "can_view", person("ida_zed")),
+    ).toBe(false);
+  });
+});
+
+describe("the walk itself", () => {
+  it("asks the source once per (object, relation) — the memo — and stops at the first true member of a union", async () => {
+    const asked: string[] = [];
+    const inner = newInMemoryTupleSource([
+      tuple("organization:acme#owner@identity_account:ida_root"),
+      tuple("agent:a#organization@organization:acme"),
+      tuple("agent:a#owner@identity_account:ida_carol"),
+    ]);
+    const counting: TupleSource = {
+      tuplesOf(object, relation) {
+        asked.push(`${object.type}:${object.id}#${relation}`);
+        return inner.tuplesOf(object, relation);
+      },
+    };
+    // can_view → viewer → this | owner | platform_viewer; owner → this | admin from organization;
+    // organization.admin → this | owner; organization.owner → this (root: true).
+    expect(
+      await allowed(counting, "agent:a", "can_view", person("ida_root")),
+    ).toBe(true);
+    const distinct = new Set(asked);
+    expect(asked.length, `each pair asked once: ${asked.join(", ")}`).toBe(
+      distinct.size,
+    );
+    // The platform_viewer arm sits AFTER owner in the union and is never reached.
+    expect(asked).not.toContain("agent:a#platform_viewer");
+  });
+
+  it("bounds the resolution at OpenFGA's own limit and reports the overrun as a fault", async () => {
+    // A chain of `next from link` deeper than the bound, on a throwaway model.
+    const deep = declareKind({
+      kind: ApiResourceKind.agent,
+      schema: AgentSchema,
+      source: "test/deep.fga",
+      relations: [
+        ["link", direct(objectOf("agent"))],
+        [
+          "next",
+          union(direct(objectOf("identity_account")), from("next", "link")),
+        ],
+      ],
+    });
+    const chain: Tuple[] = [];
+    for (let i = 0; i < MAX_RESOLUTION_DEPTH + 2; i += 1) {
+      chain.push(tuple(`agent:n${i}#link@agent:n${i + 1}`));
+    }
+    await expect(
+      checkRelation(
+        { model: newModel([deep]), source: newInMemoryTupleSource(chain) },
+        parseObjectRef("agent:n0"),
+        "next",
+        person("ida_nobody"),
+        RESOLVE,
+      ),
+    ).rejects.toMatchObject({ reason: "resolution-depth-exceeded" });
+  });
+
+  it("a declaration that re-enters itself on one object is a cycle fault, never a silent false", async () => {
+    const cyclic = declareKind({
+      kind: ApiResourceKind.agent,
+      schema: AgentSchema,
+      source: "test/cyclic.fga",
+      relations: [
+        ["a", computed("b")],
+        ["b", computed("a")],
+      ],
+    });
+    await expect(
+      checkRelation(
+        { model: newModel([cyclic]), source: newInMemoryTupleSource([]) },
+        parseObjectRef("agent:x"),
+        "a",
+        person("ida_nobody"),
+        RESOLVE,
+      ),
+    ).rejects.toBeInstanceOf(AuthorizationEvaluationError);
+  });
+});
+
+describe("declareKind validates a transcript at load", () => {
+  it("refuses a computed or tupleset reference to a relation the kind does not declare", () => {
+    expect(() =>
+      declareKind({
+        kind: ApiResourceKind.agent,
+        schema: AgentSchema,
+        source: "test/bad.fga",
+        relations: [["can_view", computed("viewer")]],
+      }),
+    ).toThrow("relation 'viewer'");
+    expect(() =>
+      declareKind({
+        kind: ApiResourceKind.agent,
+        schema: AgentSchema,
+        source: "test/bad.fga",
+        relations: [["owner", from("admin", "organization")]],
+      }),
+    ).toThrow("tupleset 'organization'");
+  });
+
+  it("refuses a relation declared twice", () => {
+    expect(() =>
+      declareKind({
+        kind: ApiResourceKind.agent,
+        schema: AgentSchema,
+        source: "test/bad.fga",
+        relations: [
+          ["viewer", direct(objectOf("identity_account"))],
+          ["viewer", direct(publicWith("identity_account", "allow_public"))],
+        ],
+      }),
+    ).toThrow("declared twice");
+  });
+
+  it("carries the FGA type name of its kind and its relations in file order", () => {
+    const declaration = declareKind({
+      kind: ApiResourceKind.mcp_server,
+      schema: AgentSchema,
+      source: "test/order.fga",
+      relations: [
+        ["organization", direct(objectOf("organization"))],
+        ["owner", direct(usersetOf("organization", "admin"))],
+        ["can_edit", computed("owner")],
+      ],
+    });
+    expect(declaration.type).toBe("mcp_server");
+    expect([...declaration.relations.keys()]).toEqual([
+      "organization",
+      "owner",
+      "can_edit",
+    ]);
+  });
+});

package/src/authorization/__tests__/facts.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Pins the one place two readers of `kind_meta.authorization` could
+ * drift: the tuple lifecycle resolves a just-persisted row into the facts
+ * a driver writes tuples from (`resolveResourceCreatedEvent`), and the
+ * built-in authorizer resolves a LOADED row into the facts it derives
+ * tuples from (`rowFactsOf`). The two are separate functions on purpose —
+ * the create-time one throws on a missing organization or parent (a
+ * create must not half-succeed), the read-time one carries what the row
+ * says (a legacy row is a fact, not a fault) — so for every declared kind
+ * a well-formed row must resolve to the same parent links and the same
+ * visibility shapes through both, and this file is where that is proven
+ * rather than remembered.
+ *
+ * The facts have a second producer since the list scope: the list lanes'
+ * shared helper builds every candidate's `ListEntryMeta` through the same
+ * structural resolver, so the second half pins that a row offered to a
+ * list carries exactly the facts the point-check driver would derive
+ * from the loaded row — the "two producers" the module header promised,
+ * proven equal.
+ */
+import { create } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+
+import { silentLogger } from "../../extensions/__tests__/composed-support.js";
+import type { CallerIdentity } from "../../extensions/identity.js";
+import type {
+  ListEntryMeta,
+  ListReadScope,
+} from "../../extensions/list-read-scope.js";
+import { restrictListByReadScope } from "../../extensions/list-read-scope.js";
+import {
+  resolveResourceCreatedEvent,
+  visibilityShapesFor,
+} from "../../pipeline/steps/authorization-tuples.js";
+import { rowFactsOf, rowFactsOfEntry } from "../facts.js";
+import { builtInModel } from "../model/index.js";
+import { fixtureRow } from "./support.js";
+
+const CREATOR: CallerIdentity = {
+  identityId: "ida_carol",
+  callerClass: "user",
+  issuer: "https://issuer.example",
+  rawToken: "opaque",
+};
+
+describe("rowFactsOf against the tuple lifecycle's own resolution", () => {
+  for (const declaration of builtInModel.declarations) {
+    for (const visibility of [
+      ApiResourceVisibility.visibility_private,
+      ApiResourceVisibility.visibility_org,
+      ApiResourceVisibility.visibility_public,
+    ]) {
+      it(`${declaration.type} at ${ApiResourceVisibility[visibility]}: the same parent links and visibility shapes`, () => {
+        const row = fixtureRow(declaration, {
+          id: `${declaration.type}-1`,
+          org: declaration.type === "organization" ? "" : "acme",
+          visibility,
+          createdBy: CREATOR.identityId,
+        });
+        const facts = rowFactsOf(declaration.kind, row);
+        const event = resolveResourceCreatedEvent(
+          declaration.kind,
+          row,
+          CREATOR,
+          silentLogger,
+        );
+        expect(facts.parentLinks).toEqual(event?.parentLinks ?? []);
+        expect([
+          ...visibilityShapesFor(declaration.kind, facts.visibility),
+        ]).toEqual(event?.visibilityShapes ?? []);
+        expect(facts.createdBy).toBe(CREATOR.identityId);
+        expect(facts.id).toBe(`${declaration.type}-1`);
+      });
+    }
+  }
+
+  it("carries a legacy row's missing organization as no scope link, where the create-time resolver throws", () => {
+    const agent = builtInModel.byType("agent");
+    if (agent === undefined) {
+      throw new Error("agent is declared in this slice");
+    }
+    const row = fixtureRow(agent, {
+      id: "agent-legacy",
+      org: "",
+      visibility: ApiResourceVisibility.visibility_org,
+      createdBy: "ida_carol",
+    });
+    expect(rowFactsOf(agent.kind, row).parentLinks).toEqual([]);
+    expect(() =>
+      resolveResourceCreatedEvent(agent.kind, row, CREATOR, silentLogger),
+    ).toThrow();
+  });
+
+  it("reads an absent creator stamp as the empty string", () => {
+    const agent = builtInModel.byType("agent");
+    if (agent === undefined) {
+      throw new Error("agent is declared in this slice");
+    }
+    const bare = create(agent.schema, {
+      metadata: { id: "agent-bare", org: "acme" },
+    });
+    expect(rowFactsOf(agent.kind, bare).createdBy).toBe("");
+  });
+});
+
+describe("a list candidate against the loaded row — the facts' two producers", () => {
+  /** What the list lanes' helper offers a scope for `rows`, captured. */
+  async function candidatesOf(
+    kind: (typeof builtInModel.declarations)[number]["kind"],
+    rows: ReadonlyArray<object>,
+  ): Promise<ReadonlyArray<ListEntryMeta>> {
+    let offered: ReadonlyArray<ListEntryMeta> = [];
+    const recording: ListReadScope = {
+      authorizedResourceIds: () => Promise.resolve(new Set<string>()),
+      restrictListEntries: (_caller, _kind, entries) => {
+        offered = entries;
+        return Promise.resolve(new Set<string>());
+      },
+    };
+    await restrictListByReadScope(
+      recording,
+      CREATOR,
+      kind,
+      rows as Array<{ metadata?: { id?: string } }>,
+      "",
+    );
+    return offered;
+  }
+
+  for (const declaration of builtInModel.declarations) {
+    for (const visibility of [
+      ApiResourceVisibility.visibility_private,
+      ApiResourceVisibility.visibility_org,
+      ApiResourceVisibility.visibility_public,
+    ]) {
+      it(`${declaration.type} at ${ApiResourceVisibility[visibility]}: the candidate the helper builds carries the facts the driver derives from`, async () => {
+        const row = fixtureRow(declaration, {
+          id: `${declaration.type}-1`,
+          org: declaration.type === "organization" ? "" : "acme",
+          visibility,
+          createdBy: CREATOR.identityId,
+        });
+        const [candidate] = await candidatesOf(declaration.kind, [row]);
+        if (candidate === undefined) {
+          throw new Error("the helper offers every row it is given");
+        }
+        expect(rowFactsOfEntry(declaration.kind, candidate)).toEqual(
+          rowFactsOf(declaration.kind, row),
+        );
+      });
+    }
+  }
+});

package/src/authorization/__tests__/fixtures/fga/agent-channel-owner.fga.yaml

@@ -0,0 +1,112 @@
+# Pinned copy of stigmer-cloud backend/services/stigmer-server/fga/tests/agent-channel-owner.fga.yaml
+# at commit b87dd1170 (the OpenFGA store test the cloud runs against its live model).
+# The body below is byte-identical to the source; the cloud re-runs the LIVE
+# file against this evaluator at the re-pin, so a stale copy is caught there.
+# Agent channels are owner-scoped connection config (channel-integrations
+# decision 001, cloned from the agent_share model): the creator owns the
+# channel; view/edit/delete/install require ownership or an explicit grant.
+# Plain org members get NO implicit access, and — critically — no
+# workspace-visitor tuples exist at all: workspace-user admission to the
+# channel runtime is app-level (webhook signature + channel caller identity
+# + per-turn gates), never FGA.
+#
+# Org ADMINS inherit owner (T08, consistent with agents and shares — an
+# admin who can edit the agent can manage its distribution channels). The
+# narrowness these tests pin: owner + admins have control, granted viewers
+# read, plain members have nothing.
+#
+# Run: fga model test --tests agent-channel-owner.fga.yaml
+
+name: agent-channel-owner
+model_file: ../model/fga.mod
+
+tuples:
+  # Org membership for both accounts — proving membership grants nothing.
+  - user: identity_account:alice
+    relation: member
+    object: organization:acme
+  - user: identity_account:mallory
+    relation: member
+    object: organization:acme
+
+  # Org admin — proving T08 inheritance reaches channels.
+  - user: identity_account:ana
+    relation: admin
+    object: organization:acme
+
+  # The channel, created by alice (the config-driven create tuples).
+  - user: organization:acme
+    relation: organization
+    object: agent_channel:support-bot-slack
+  - user: identity_account:alice
+    relation: owner
+    object: agent_channel:support-bot-slack
+
+  # An explicit viewer grant to carol (not even an org member).
+  - user: identity_account:carol
+    relation: viewer
+    object: agent_channel:support-bot-slack
+
+tests:
+  - name: owner has full control including grant management
+    check:
+      - user: identity_account:alice
+        object: agent_channel:support-bot-slack
+        assertions:
+          can_view: true
+          can_edit: true
+          can_delete: true
+          can_grant_access: true
+          can_view_access: true
+
+  - name: explicitly granted viewer can read but not mutate
+    check:
+      - user: identity_account:carol
+        object: agent_channel:support-bot-slack
+        assertions:
+          can_view: true
+          can_edit: false
+          can_delete: false
+          can_grant_access: false
+          can_view_access: true
+
+  - name: fellow org member has no implicit access
+    check:
+      - user: identity_account:mallory
+        object: agent_channel:support-bot-slack
+        assertions:
+          can_view: false
+          can_edit: false
+          can_delete: false
+          can_grant_access: false
+          can_view_access: false
+
+  - name: org admin inherits channel management (T08)
+    check:
+      - user: identity_account:ana
+        object: agent_channel:support-bot-slack
+        assertions:
+          can_view: true
+          can_edit: true
+          can_delete: true
+          can_grant_access: true
+
+  - name: listing channels reflects ownership and grants, not membership
+    list_objects:
+      - user: identity_account:alice
+        type: agent_channel
+        assertions:
+          can_view:
+            - agent_channel:support-bot-slack
+          can_edit:
+            - agent_channel:support-bot-slack
+      - user: identity_account:carol
+        type: agent_channel
+        assertions:
+          can_view:
+            - agent_channel:support-bot-slack
+          can_edit: []
+      - user: identity_account:mallory
+        type: agent_channel
+        assertions:
+          can_view: []