@stigmer/cli 3.11.0 → 3.12.0

package/src/resources/apply/apply.integration.test.ts

@@ -19,8 +19,6 @@ import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { AgentCommandController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/command_pb";
 import type { ChannelApp } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
 import { ChannelAppCommandController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/command_pb";
-import type { Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
-import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { McpServerCommandController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/command_pb";
 import { createNodeTransport, normalizeEndpoint } from "@stigmer/sdk/node";
@@ -34,13 +32,11 @@ const openSessions = new Set<ServerHttp2Session>();
 
 let appliedAgents: Agent[] = [];
 let appliedMcps: McpServer[] = [];
-let appliedDatastores: Datastore[] = [];
 let appliedChannelApps: ChannelApp[] = [];
 
 beforeEach(() => {
   appliedAgents = [];
   appliedMcps = [];
-  appliedDatastores = [];
   appliedChannelApps = [];
 });
 
@@ -64,12 +60,6 @@ beforeAll(async () => {
         return req;
       },
     });
-    router.service(DatastoreCommandController, {
-      apply: (req) => {
-        appliedDatastores.push(req);
-        return req;
-      },
-    });
     router.service(ChannelAppCommandController, {
       apply: (req) => {
         appliedChannelApps.push(req);
@@ -166,64 +156,7 @@ describe("file-mode apply — fidelity (raw controller preserves full proto)", (
   });
 });
 
-const DATASTORE_YAML = [
-  "apiVersion: agentic.stigmer.ai/v1",
-  "kind: Datastore",
-  "metadata:",
-  "  name: clinic-records",
-  "  slug: clinic-records",
-  "spec:",
-  "  timezone: Asia/Kolkata",
-  "  authorization:",
-  "    roles:",
-  "      - name: patient",
-  "    default_role: patient",
-  "  collections:",
-  "    - name: bookings",
-  "      fields:",
-  "        - name: slot_start",
-  "          type: timestamp",
-  "          required: true",
-  "      uniques:",
-  "        - name: one_per_slot",
-  "          fields: [slot_start]",
-  '          message: "that slot is already booked"',
-  "",
-].join("\n");
-
-describe("file-mode apply — datastore", () => {
-  it("applies a Datastore through the raw controller with the spec intact", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "apply-it-"));
-    try {
-      writeYaml(dir, "datastore.yaml", DATASTORE_YAML);
-      const items = resolveApplyItems(dir);
-      expect(items).toHaveLength(1);
-
-      const outcome = await applyItem(controllerFn, items[0], "acme", false);
-      expect(outcome.result.message).toBe("Datastore created successfully");
-
-      expect(appliedDatastores).toHaveLength(1);
-      const spec = appliedDatastores[0].spec;
-      expect(spec?.timezone).toBe("Asia/Kolkata");
-      expect(spec?.authorization?.defaultRole).toBe("patient");
-      expect(spec?.collections[0]?.uniques[0]?.message).toBe("that slot is already booked");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
 
-  it("sorts a Datastore before the Agent that references it", () => {
-    const dir = mkdtempSync(join(tmpdir(), "apply-it-"));
-    try {
-      writeYaml(dir, "agent.yaml", AGENT_WITH_ID);
-      writeYaml(dir, "datastore.yaml", DATASTORE_YAML);
-      const items = resolveApplyItems(dir);
-      expect(items.map((i) => i.handler.displayName)).toEqual(["Datastore", "Agent"]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
 
 // The stigmer/stigmer#353 regression block: ChannelApp apply used to fail
 // with "apply not implemented for Channel App" because the CLI's handler

package/src/resources/delete.ts

@@ -45,9 +45,8 @@ interface HasMetadata {
   readonly metadata?: { readonly id?: string; readonly name?: string; readonly slug?: string; readonly org?: string };
 }
 
-// `force` is the RPC-level acknowledgment of destructive side effects (e.g. a
-// datastore's held records) — distinct from, but carried by, the CLI's
-// `-f/--force` flag. Kinds whose delete RPC takes a plain typed ID have no
+// `force` is the RPC-level acknowledgment of destructive side effects —
+// distinct from, but carried by, the CLI's `-f/--force` flag. Kinds whose delete RPC takes a plain typed ID have no
 // force field and simply ignore the argument.
 type DeleteFn = (client: Stigmer, id: string, force: boolean) => Promise<HasMetadata>;
 
@@ -56,8 +55,7 @@ type DeleteFn = (client: Stigmer, id: string, force: boolean) => Promise<HasMeta
 // documented special case) — the conformance test in registry/registry.test.ts
 // enforces it, so the two cannot drift.
 // Kinds whose delete takes a DeleteResourceInput (not an ID) thread the force
-// acknowledgment through; today only the datastore server honors it (the
-// non-empty guard), but force is the contract's generic ack carrier.
+// acknowledgment through — force is the contract's generic ack carrier.
 export const DELETE_HANDLERS: ReadonlyMap<ApiResourceKind, DeleteFn> = new Map<ApiResourceKind, DeleteFn>([
   [ApiResourceKind.agent, (c, id) => c.agent.delete(id)],
   [ApiResourceKind.agent_instance, (c, id) => c.agentInstance.delete(id)],
@@ -65,7 +63,6 @@ export const DELETE_HANDLERS: ReadonlyMap<ApiResourceKind, DeleteFn> = new Map<A
   [ApiResourceKind.workflow_instance, (c, id) => c.workflowInstance.delete(id)],
   [ApiResourceKind.mcp_server, (c, id, force) => c.mcpServer.delete({ resourceId: id, force })],
   [ApiResourceKind.project, (c, id) => c.project.delete(id)],
-  [ApiResourceKind.datastore, (c, id, force) => c.datastore.delete({ resourceId: id, force })],
   [ApiResourceKind.environment, (c, id, force) => c.environment.delete({ resourceId: id, force })],
   [ApiResourceKind.agent_channel, (c, id) => c.agentChannel.delete(id)],
   [ApiResourceKind.channel_app, (c, id, force) => c.channelapp.delete({ resourceId: id, force })],
@@ -230,13 +227,6 @@ function buildDeleteWarning(info: TypeInfo, message: HasMetadata): CommandResult
     warning.hint("This will delete the skill and all its versions.");
   }
 
-  if (info.kind === ApiResourceKind.datastore) {
-    // Mirrors the server's non-empty guard (GuardNonEmptyStep): the delete of
-    // a datastore holding records is refused unless force acknowledges it.
-    warning.hint("All records held by this datastore will be destroyed.");
-    warning.hint("A datastore holding records is refused unless --force acknowledges destroying them.");
-  }
-
   if (info.kind === ApiResourceKind.agent_channel) {
     // The server's documented distinction: delete is the connection's full
     // teardown; disabling is the config-preserving pause.

package/src/resources/get-bindings.ts

@@ -8,7 +8,6 @@ import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb"
 import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
 import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
 import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
-import { DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
 import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
@@ -39,7 +38,6 @@ export const GET_BINDINGS: ReadonlyMap<ApiResourceKind, Getter> = new Map([
   [ApiResourceKind.workflow_instance, refGetter(ApiResourceKind.workflow_instance, WorkflowInstanceSchema, (c) => c.workflowInstance)],
   [ApiResourceKind.mcp_server, refGetter(ApiResourceKind.mcp_server, McpServerSchema, (c) => c.mcpServer)],
   [ApiResourceKind.project, refGetter(ApiResourceKind.project, ProjectSchema, (c) => c.project)],
-  [ApiResourceKind.datastore, refGetter(ApiResourceKind.datastore, DatastoreSchema, (c) => c.datastore)],
   [ApiResourceKind.environment, refGetter(ApiResourceKind.environment, EnvironmentSchema, (c) => c.environment)],
   [ApiResourceKind.agent_channel, refGetter(ApiResourceKind.agent_channel, AgentChannelSchema, (c) => c.agentChannel)],
   [ApiResourceKind.channel_app, refGetter(ApiResourceKind.channel_app, ChannelAppSchema, (c) => c.channelapp)],

package/src/resources/list.ts

@@ -7,8 +7,14 @@
 // registered in LIST_HANDLERS — the same map-dispatch shape as the get,
 // delete, and apply registries, so the conformance test in
 // registry/registry.test.ts can hold all four to the verb matrix.
+//
+// Handlers FETCH, the dispatcher RENDERS: every handler returns entries plus
+// its schema/table pair, and listResources alone applies --limit and renders.
+// That split is deliberate (stigmer/stigmer#312): when handlers owned
+// rendering, honoring --limit was per-handler discipline, and the two
+// unpaginated branches (organization, api_key) shipped silently ignoring it.
 
-import { create } from "@bufbuild/protobuf";
+import { create, type DescMessage, type Message } from "@bufbuild/protobuf";
 import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
 import { ListAgentChannelsRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/io_pb";
 import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
@@ -39,11 +45,22 @@ export const SEARCH_KINDS: ReadonlySet<ApiResourceKind> = new Set<ApiResourceKin
   ApiResourceKind.mcp_server,
   ApiResourceKind.project,
   ApiResourceKind.skill,
-  ApiResourceKind.datastore,
   ApiResourceKind.environment,
 ]);
 
-type ListFn = (client: Stigmer, org: string, limit: number, format: OutputFormat) => Promise<string>;
+// One fetched page of a listing: what to render (entries + schema) and how
+// (table). Rendering and --limit truncation happen centrally in
+// listResources — a handler cannot opt out of either.
+interface ListPage {
+  readonly schema: DescMessage;
+  readonly entries: readonly Message[];
+  readonly table: TableShape;
+}
+
+// Where the RPC paginates, the handler still forwards `limit` as the page
+// size so the server does the bounding; the dispatcher's slice is then a
+// no-op. Where it doesn't, the slice IS the bound.
+type ListFn = (client: Stigmer, org: string, limit: number) => Promise<ListPage>;
 
 // Dedicated-RPC list handlers for the non-search-indexed kinds. Every kind
 // declaring List in the verb matrix must appear here or in SEARCH_KINDS —
@@ -51,49 +68,53 @@ type ListFn = (client: Stigmer, org: string, limit: number, format: OutputFormat
 export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiResourceKind, ListFn>([
   [
     ApiResourceKind.organization,
-    async (client, _org, _limit, format) => {
+    async (client) => {
+      // findMyOrganizations is caller-scoped and unpaginated (Empty request;
+      // a caller's org set is small by nature). The paginated `find` RPC is
+      // platform-admin-only — the wrong surface for `list organization`.
       const result = await client.organization.findMyOrganizations();
-      return renderCollection(OrganizationSchema, result.entries, format, ORG_TABLE);
+      return { schema: OrganizationSchema, entries: result.entries, table: ORG_TABLE };
     },
   ],
   [
     ApiResourceKind.api_key,
-    async (client, _org, _limit, format) => {
+    async (client) => {
+      // findAll is caller-scoped and unpaginated (Empty request).
       const result = await client.apiKey.findAll();
-      return renderCollection(ApiKeySchema, result.entries, format, APIKEY_TABLE);
+      return { schema: ApiKeySchema, entries: result.entries, table: APIKEY_TABLE };
     },
   ],
   [
     ApiResourceKind.agent_instance,
-    async (client, org, limit, format) => {
+    async (client, org, limit) => {
       const result = await client.agentInstance.list(
         create(ListAgentInstancesRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
       );
-      return renderCollection(AgentInstanceSchema, result.items, format, INSTANCE_TABLE);
+      return { schema: AgentInstanceSchema, entries: result.items, table: INSTANCE_TABLE };
     },
   ],
   [
     ApiResourceKind.agent_channel,
-    async (client, org, limit, format) => {
+    async (client, org, limit) => {
       const result = await client.agentChannel.list(
         create(ListAgentChannelsRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
       );
-      return renderCollection(AgentChannelSchema, result.items, format, AGENT_CHANNEL_TABLE);
+      return { schema: AgentChannelSchema, entries: result.items, table: AGENT_CHANNEL_TABLE };
     },
   ],
   [
     ApiResourceKind.channel_app,
-    async (client, org, limit, format) => {
+    async (client, org) => {
       // listByOrg has no pagination on its contract (the per-org set is small
-      // by design); the limit is applied client-side so --limit stays honest.
+      // by design); the dispatcher's slice bounds the output.
       // `channelapp` (not `channelApp`) is a recorded SDK codegen naming quirk.
       const result = await client.channelapp.listByOrg(create(ListChannelAppsByOrgInputSchema, { org }));
-      return renderCollection(ChannelAppSchema, result.entries.slice(0, limit), format, CHANNEL_APP_TABLE);
+      return { schema: ChannelAppSchema, entries: result.entries, table: CHANNEL_APP_TABLE };
     },
   ],
   [
     ApiResourceKind.schedule,
-    async (client, org, limit, format) => {
+    async (client, org, limit) => {
       // ListSchedulesRequest requires an org (min_len 1), but an unset cloud
       // context resolves to "" — refuse with actionable copy instead of
       // relaying the server's raw validation error.
@@ -105,7 +126,7 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
       const result = await client.schedule.list(
         create(ListSchedulesRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
       );
-      return renderCollection(ScheduleSchema, result.items, format, SCHEDULE_TABLE);
+      return { schema: ScheduleSchema, entries: result.items, table: SCHEDULE_TABLE };
     },
   ],
 ]);
@@ -117,15 +138,31 @@ export async function listResources(
   limit: number,
   format: OutputFormat,
 ): Promise<string> {
+  const page = await fetchListPage(client, kind, org, limit);
+  // The single point where --limit binds the output. For paginated RPCs the
+  // handler already asked the server for at most `limit` entries and this is
+  // a no-op; for unpaginated RPCs it is the truncation itself. Slicing here
+  // rather than per-handler is what keeps the flag honest for every kind —
+  // organization and api_key shipped ignoring it when handlers owned this
+  // (stigmer/stigmer#312).
+  return renderCollection(page.schema, page.entries.slice(0, limit), format, page.table);
+}
+
+async function fetchListPage(
+  client: Stigmer,
+  kind: ApiResourceKind,
+  org: string,
+  limit: number,
+): Promise<ListPage> {
   const dedicated = LIST_HANDLERS.get(kind);
   if (dedicated !== undefined) {
-    return dedicated(client, org, limit, format);
+    return dedicated(client, org, limit);
   }
   if (!SEARCH_KINDS.has(kind)) {
     throw new UsageError("list is not implemented for this resource type");
   }
   const result = await client.search.query({ kinds: [kind], org, page: { num: 1, size: limit } });
-  return renderCollection(SearchResultSchema, result.entries, format, SEARCH_TABLE);
+  return { schema: SearchResultSchema, entries: result.entries, table: SEARCH_TABLE };
 }
 
 // Shared with `search` — both render SearchService results identically.

package/src/resources/mutate-verbs.integration.test.ts

@@ -25,9 +25,6 @@ import { AgentInstanceQueryController } from "@stigmer/protos/ai/stigmer/agentic
 import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
 import { ChannelAppCommandController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/command_pb";
 import { ChannelAppQueryController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/query_pb";
-import { DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
-import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
-import { DatastoreQueryController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/query_pb";
 import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { EnvironmentCommandController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/command_pb";
 import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
@@ -69,16 +66,6 @@ const knownWorkflow = create(WorkflowSchema, {
   metadata: { name: "Deploy", slug: "deploy", org: "acme", id: "wfl_1" },
 });
 
-// The mock treats this datastore as NON-EMPTY: delete refuses without the
-// force acknowledgment, mirroring the server's GuardNonEmptyStep contract.
-const knownDatastore = create(DatastoreSchema, {
-  metadata: { name: "clinic-records", slug: "clinic-records", org: "acme", id: "dst_1" },
-});
-
-// Byte-shaped like the Go server's GuardNonEmptyStep refusal (delete_guards.go).
-const nonEmptyGuardMessage =
-  'datastore "clinic-records" holds 12 records across 3 collections; deleting destroys them — pass force to acknowledge';
-
 const knownEnvironment = create(EnvironmentSchema, {
   metadata: { name: "clinic-patient-db", slug: "clinic-patient-db", org: "acme", id: "env_1" },
 });
@@ -121,7 +108,6 @@ const openSessions = new Set<ServerHttp2Session>();
 let cancelCalls: string[] = [];
 let tagCalls: { workflowId: string; versionHash: string; tag: string }[] = [];
 // Force-carrying deletes record what actually rode the RPC.
-let datastoreDeletes: { resourceId: string; force: boolean }[] = [];
 let environmentDeletes: { resourceId: string; force: boolean }[] = [];
 let channelAppDeletes: { resourceId: string; force: boolean }[] = [];
 // agent_channel, schedule, and workflow_instance delete by typed ID — no
@@ -133,7 +119,6 @@ let workflowInstanceDeleteIds: string[] = [];
 beforeEach(() => {
   cancelCalls = [];
   tagCalls = [];
-  datastoreDeletes = [];
   environmentDeletes = [];
   channelAppDeletes = [];
   channelDeleteIds = [];
@@ -181,21 +166,6 @@ beforeAll(async () => {
       },
     });
 
-    router.service(DatastoreQueryController, {
-      getByReference: (req) => {
-        if (req.slug !== "clinic-records") throw new ConnectError("datastore not found", Code.NotFound);
-        return knownDatastore;
-      },
-    });
-    router.service(DatastoreCommandController, {
-      delete: (req) => {
-        datastoreDeletes.push({ resourceId: req.resourceId, force: req.force });
-        // Mirrors GuardNonEmptyStep: a non-empty datastore refuses without force.
-        if (!req.force) throw new ConnectError(nonEmptyGuardMessage, Code.FailedPrecondition);
-        return knownDatastore;
-      },
-    });
-
     router.service(EnvironmentQueryController, {
       getByReference: (req) => {
         if (req.slug !== "clinic-patient-db") throw new ConnectError("environment not found", Code.NotFound);
@@ -374,7 +344,6 @@ describe("delete (standard kinds)", () => {
     // it must name the wired kinds and never the narrowed ones (#354).
     const message = String(err.message);
     for (const wired of [
-      "datastore",
       "environment",
       "agentchannel",
       "channelapp",
@@ -399,37 +368,6 @@ describe("delete (standard kinds)", () => {
   });
 });
 
-describe("delete (force acknowledgment)", () => {
-  it("threads --force to the datastore delete RPC as the destroy-records ack", async () => {
-    const plan = await planDelete(client, "datastore", "clinic-records", "acme", true);
-    const result = await plan.perform();
-
-    expect(result.status).toBe("success");
-    expect(result.message).toBe("Datastore deleted successfully");
-    expect(datastoreDeletes).toEqual([{ resourceId: "dst_1", force: true }]);
-  });
-
-  it("surfaces the non-empty guard refusal verbatim when force is absent", async () => {
-    const plan = await planDelete(client, "datastore", "clinic-records", "acme");
-    const err = await plan.perform().catch((e) => e);
-
-    // A confirmed-but-unforced delete must NOT bypass the server guard: the
-    // RPC carries force=false and the refusal reaches the user verbatim.
-    expect(datastoreDeletes).toEqual([{ resourceId: "dst_1", force: false }]);
-    const classified = classify(err);
-    expect(classified?.exitCode).toBe(ExitCode.Usage);
-    expect(classified?.message).toBe(`Precondition failed: ${nonEmptyGuardMessage}`);
-  });
-
-  it("warns up front that datastore records are destroyed and force-guarded", async () => {
-    const plan = await planDelete(client, "datastore", "clinic-records", "acme");
-    expect(plan.warning.hints).toContain("All records held by this datastore will be destroyed.");
-    expect(plan.warning.hints).toContain(
-      "A datastore holding records is refused unless --force acknowledges destroying them.",
-    );
-  });
-});
-
 describe("delete (cutover kinds: environment, agent channel, channel app)", () => {
   it("deletes an environment via the DeleteResourceInput shape", async () => {
     const plan = await planDelete(client, "environment", "clinic-patient-db", "acme");

package/src/resources/read-verbs.integration.test.ts

@@ -67,6 +67,23 @@ const knownApiKey = create(ApiKeySchema, {
   spec: { fingerprint: "abcd", neverExpires: true },
 });
 
+// Second org/API-key entries so the list tests can pin the
+// dispatcher-applied --limit slice — both RPCs are unpaginated (Empty
+// request), the exact shape that shipped ignoring the flag when handlers
+// owned rendering (stigmer/stigmer#312).
+const secondOrg = create(OrganizationSchema, {
+  apiVersion: "tenancy.stigmer.ai/v1",
+  kind: "Organization",
+  metadata: { name: "Beta Clinic", slug: "beta-clinic", org: "beta-clinic", id: "beta-clinic" },
+});
+
+const secondApiKey = create(ApiKeySchema, {
+  apiVersion: "iam.stigmer.ai/v1",
+  kind: "ApiKey",
+  metadata: { name: "local-dev", org: "acme", id: "key_2" },
+  spec: { fingerprint: "ef01", neverExpires: true },
+});
+
 const knownSearchResult = create(SearchResultSchema, {
   kind: ApiResourceKind.agent,
   id: "agt_1",
@@ -223,10 +240,10 @@ beforeAll(async () => {
       },
     });
     router.service(OrganizationQueryController, {
-      findMyOrganizations: () => ({ entries: [knownOrg] }),
+      findMyOrganizations: () => ({ entries: [knownOrg, secondOrg] }),
     });
     router.service(ApiKeyQueryController, {
-      findAll: () => ({ entries: [knownApiKey] }),
+      findAll: () => ({ entries: [knownApiKey, secondApiKey] }),
     });
     router.service(EnvironmentQueryController, {
       get: (req) => {
@@ -441,11 +458,27 @@ describe("list integration", () => {
 
   it("lists organizations via findMyOrganizations as JSON", async () => {
     const out = await listResources(client, ApiResourceKind.organization, "acme", 50, "json");
+    expect(JSON.parse(out)).toEqual([
+      toJson(OrganizationSchema, knownOrg, { useProtoFieldName: true }),
+      toJson(OrganizationSchema, secondOrg, { useProtoFieldName: true }),
+    ]);
+  });
+
+  it("applies --limit to organizations (findMyOrganizations has no pagination)", async () => {
+    const out = await listResources(client, ApiResourceKind.organization, "acme", 1, "json");
     expect(JSON.parse(out)).toEqual([toJson(OrganizationSchema, knownOrg, { useProtoFieldName: true })]);
   });
 
   it("lists API keys via findAll as JSON", async () => {
     const out = await listResources(client, ApiResourceKind.api_key, "acme", 50, "json");
+    expect(JSON.parse(out)).toEqual([
+      toJson(ApiKeySchema, knownApiKey, { useProtoFieldName: true }),
+      toJson(ApiKeySchema, secondApiKey, { useProtoFieldName: true }),
+    ]);
+  });
+
+  it("applies --limit to API keys (findAll has no pagination)", async () => {
+    const out = await listResources(client, ApiResourceKind.api_key, "acme", 1, "json");
     expect(JSON.parse(out)).toEqual([toJson(ApiKeySchema, knownApiKey, { useProtoFieldName: true })]);
   });
 

package/src/resources/usage.ts

@@ -41,10 +41,11 @@ export async function getSessionUsageReport(client: Stigmer, sessionId: string):
 export async function getAgentUsageReport(
   client: Stigmer,
   agentId: string,
+  orgId: string,
   range: DateRange,
 ): Promise<GetAgentUsageReportOutput> {
   return client.agentExecution.getAgentUsageReport(
-    create(GetAgentUsageReportInputSchema, { agentId, fromDate: range.from, toDate: range.to }),
+    create(GetAgentUsageReportInputSchema, { agentId, orgId, fromDate: range.from, toDate: range.to }),
   );
 }
 

package/src/resources/validate.ts

@@ -7,7 +7,6 @@
 
 import { type DescMessage, fromJson, type JsonValue } from "@bufbuild/protobuf";
 import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import { DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
@@ -22,7 +21,6 @@ export const VALIDATE_SCHEMAS: ReadonlyMap<ApiResourceKind, DescMessage> = new M
   [ApiResourceKind.workflow, WorkflowSchema],
   [ApiResourceKind.mcp_server, McpServerSchema],
   [ApiResourceKind.project, ProjectSchema],
-  [ApiResourceKind.datastore, DatastoreSchema],
 ]);
 
 export function schemaForValidate(kind: ApiResourceKind): DescMessage | undefined {